home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / etc / bash_completion < prev    next >
Text File  |  2009-10-05  |  219KB  |  9,349 lines
  1. # -*- mode: shell-script; sh-basic-offset: 8; indent-tabs-mode: t -*-
  2. # ex: ts=8 sw=8 noet filetype=sh
  3. #
  4. #   bash_completion - programmable completion functions for bash 3.x
  5. #              (backwards compatible with bash 2.05b)
  6. #
  7. #   Copyright ┬⌐ 2006-2008, Ian Macdonald <ian@caliban.org>
  8. #             ┬⌐ 2009, Bash Completion Maintainers
  9. #                     <bash-completion-devel@lists.alioth.debian.org>
  10. #
  11. #   This program is free software; you can redistribute it and/or modify
  12. #   it under the terms of the GNU General Public License as published by
  13. #   the Free Software Foundation; either version 2, or (at your option)
  14. #   any later version.
  15. #
  16. #   This program is distributed in the hope that it will be useful,
  17. #   but WITHOUT ANY WARRANTY; without even the implied warranty of
  18. #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19. #   GNU General Public License for more details.
  20. #
  21. #   You should have received a copy of the GNU General Public License
  22. #   along with this program; if not, write to the Free Software Foundation,
  23. #   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  24. #
  25. #   The latest version of this software can be obtained here:
  26. #
  27. #   http://bash-completion.alioth.debian.org/
  28. #
  29. #   RELEASE: 1.0
  30.  
  31. if [[ $- == *v* ]]; then
  32.     BASH_COMPLETION_ORIGINAL_V_VALUE="-v"
  33. else
  34.     BASH_COMPLETION_ORIGINAL_V_VALUE="+v"
  35. fi
  36.  
  37. if [[ -n $BASH_COMPLETION_DEBUG ]]; then
  38.     set -v
  39. else
  40.     set +v
  41. fi
  42.  
  43. # Alter the following to reflect the location of this file.
  44. #
  45. [ -n "$BASH_COMPLETION" ] || BASH_COMPLETION=/etc/bash_completion
  46. [ -n "$BASH_COMPLETION_DIR" ] || BASH_COMPLETION_DIR=/etc/bash_completion.d
  47. readonly BASH_COMPLETION BASH_COMPLETION_DIR
  48.  
  49. # Set a couple of useful vars
  50. #
  51. UNAME=$( uname -s )
  52. # strip OS type and version under Cygwin (e.g. CYGWIN_NT-5.1 => Cygwin)
  53. UNAME=${UNAME/CYGWIN_*/Cygwin}
  54. RELEASE=$( uname -r )
  55.  
  56. case ${UNAME} in
  57.     Linux|GNU|GNU/*) USERLAND=GNU ;;
  58.     *) USERLAND=${UNAME} ;;
  59. esac
  60.  
  61. # features supported by bash 2.05 and higher
  62. if [ ${BASH_VERSINFO[0]} -eq 2 ] && [[ ${BASH_VERSINFO[1]} > 04 ]] ||
  63.    [ ${BASH_VERSINFO[0]} -gt 2 ]; then
  64.     declare -r bash205=$BASH_VERSION 2>/dev/null || :
  65.     default="-o default"
  66.     dirnames="-o dirnames"
  67.     filenames="-o filenames"
  68. fi
  69. # features supported by bash 2.05b and higher
  70. if [ ${BASH_VERSINFO[0]} -eq 2 ] && [[ ${BASH_VERSINFO[1]} = "05b" ]] ||
  71.    [ ${BASH_VERSINFO[0]} -gt 2 ]; then
  72.     declare -r bash205b=$BASH_VERSION 2>/dev/null || :
  73.     nospace="-o nospace"
  74. fi
  75. # features supported by bash 3.0 and higher
  76. if [ ${BASH_VERSINFO[0]} -gt 2 ]; then
  77.     declare -r bash3=$BASH_VERSION 2>/dev/null || :
  78.     bashdefault="-o bashdefault"
  79.     plusdirs="-o plusdirs"
  80. fi
  81.  
  82. # Turn on extended globbing and programmable completion
  83. shopt -s extglob progcomp
  84.  
  85. # A lot of the following one-liners were taken directly from the
  86. # completion examples provided with the bash 2.04 source distribution
  87.  
  88. # Make directory commands see only directories
  89. complete -d pushd
  90.  
  91. # The following section lists completions that are redefined later
  92. # Do NOT break these over multiple lines.
  93. #
  94. # START exclude -- do NOT remove this line
  95. complete -f -X '!*.?(t)bz?(2)' bunzip2
  96. # TODO: see #455510
  97. #complete -f -X '!*.?(t)bz?(2)' bzcat bzcmp bzdiff bzegrep bzfgrep bzgrep
  98. complete -f -X '!*.*' bzcat bzcmp bzdiff bzegrep bzfgrep bzgrep
  99. complete -f -X '!*.@(zip|ZIP|jar|JAR|exe|EXE|pk3|war|wsz|ear|zargo|xpi|sxw|ott|od[fgpst]|epub)' unzip zipinfo
  100. complete -f -X '*.Z' compress znew
  101. complete -f -X '!*.@(Z|gz|tgz|Gz|dz)' gunzip
  102. # TODO: see #455510
  103. #complete -f -X '!*.@(Z|gz|tgz|Gz|dz)' zcmp zdiff zcat zegrep zfgrep zgrep zless zmore
  104. complete -f -X '!*.*' zcmp zdiff zcat zegrep zfgrep zgrep zless zmore
  105. complete -f -X '!*.Z' uncompress
  106. complete -f -X '!*.@(gif|jp?(e)g|miff|tif?(f)|pn[gm]|p[bgp]m|bmp|xpm|ico|xwd|tga|pcx|GIF|JP?(E)G|MIFF|TIF?(F)|PN[GM]|P[BGP]M|BMP|XPM|ICO|XWD|TGA|PCX)' ee
  107. complete -f -X '!*.@(gif|jp?(e)g|tif?(f)|png|p[bgp]m|bmp|x[bp]m|rle|rgb|pcx|fits|pm|GIF|JPG|JP?(E)G|TIF?(F)|PNG|P[BGP]M|BMP|X[BP]M|RLE|RGB|PCX|FITS|PM)' xv qiv
  108. complete -f -X '!*.@(@(?(e)ps|?(E)PS|pdf|PDF)?(.gz|.GZ|.bz2|.BZ2|.Z))' gv ggv kghostview
  109. complete -f -X '!*.@(dvi|DVI)?(.@(gz|Z|bz2))' xdvi
  110. complete -f -X '!*.@(dvi|DVI)?(.@(gz|Z|bz2))' kdvi
  111. complete -f -X '!*.@(dvi|DVI)' dvips dviselect dvitype dvipdf advi dvipdfm dvipdfmx
  112. complete -f -X '!*.@(pdf|PDF)' acroread gpdf xpdf
  113. complete -f -X '!*.@(?(e)ps|?(E)PS|pdf|PDF)' kpdf
  114. complete -f -X '!*.@(@(?(e)ps|?(E)PS|pdf|PDF|dvi|DVI)?(.gz|.GZ|.bz2|.BZ2)|cb[rz]|CB[RZ]|djv?(u)|DJV?(U)|dvi|DVI|gif|jp?(e)g|miff|tif?(f)|pn[gm]|p[bgp]m|bmp|xpm|ico|xwd|tga|pcx|GIF|JP?(E)G|MIFF|TIF?(F)|PN[GM]|P[BGP]M|BMP|XPM|ICO|XWD|TGA|PCX)' evince okular
  115. complete -f -X '!*.@(?(e)ps|?(E)PS|pdf|PDF)' ps2pdf ps2pdf12 ps2pdf13 ps2pdf14 ps2pdfwr
  116. complete -f -X '!*.texi*' makeinfo texi2html
  117. complete -f -X '!*.@(?(la)tex|?(LA)TEX|texi|TEXI|dtx|DTX|ins|INS)' tex latex slitex jadetex pdfjadetex pdftex pdflatex texi2dvi
  118. complete -f -X '!*.@(mp3|MP3)' mpg123 mpg321 madplay
  119. complete -f -X '!*@(.@(mp?(e)g|MP?(E)G|wma|avi|AVI|asf|vob|VOB|bin|dat|divx|DIVX|vcd|ps|pes|fli|flv|FLV|viv|rm|ram|yuv|mov|MOV|qt|QT|wmv|mp[234]|MP[234]|m4[pv]|M4[PV]|mkv|MKV|ogg|OGG|ogm|OGM|wav|WAV|asx|ASX|mng|MNG|srt)|+([0-9]).@(vdr|VDR))' xine aaxine fbxine kaffeine
  120. complete -f -X '!*.@(avi|asf|wmv)' aviplay
  121. complete -f -X '!*.@(rm?(j)|ra?(m)|smi?(l))' realplay
  122. complete -f -X '!*.@(mpg|mpeg|avi|mov|qt)' xanim
  123. complete -f -X '!*.@(ogg|OGG|m3u|flac|spx)' ogg123
  124. complete -f -X '!*.@(mp3|MP3|ogg|OGG|pls|m3u)' gqmpeg freeamp
  125. complete -f -X '!*.fig' xfig
  126. complete -f -X '!*.@(mid?(i)|MID?(I)|cmf|CMF)' playmidi
  127. complete -f -X '!*.@(mid?(i)|MID?(I)|rmi|RMI|rcp|RCP|[gr]36|[GR]36|g18|G18|mod|MOD|xm|XM|it|IT|x3m|X3M|kar|KAR)' timidity
  128. complete -f -X '*.@(o|so|so.!(conf)|a|rpm|gif|GIF|jp?(e)g|JP?(E)G|mp3|MP3|mp?(e)g|MPG|avi|AVI|asf|ASF|ogg|OGG|class|CLASS)' vi vim gvim rvim view rview rgvim rgview gview
  129. complete -f -X '*.@(o|so|so.!(conf)|a|rpm|gif|GIF|jp?(e)g|JP?(E)G|mp3|MP3|mp?(e)g|MPG|avi|AVI|asf|ASF|ogg|OGG|class|CLASS)' emacs
  130. complete -f -X '!*.@(exe|EXE|com|COM|scr|SCR|exe.so)' wine
  131. complete -f -X '!*.@(zip|ZIP|z|Z|gz|GZ|tgz|TGZ)' bzme
  132. complete -f -X '!*.@(?([xX]|[sS])[hH][tT][mM]?([lL]))' netscape mozilla lynx opera galeon curl dillo elinks amaya
  133. complete -f -X '!*.@(sxw|stw|sxg|sgl|doc|dot|rtf|txt|htm|html|odt|ott|odm)' oowriter
  134. complete -f -X '!*.@(sxi|sti|pps|ppt|pot|odp|otp)' ooimpress
  135. complete -f -X '!*.@(sxc|stc|xls|xlw|xlt|csv|ods|ots)' oocalc
  136. complete -f -X '!*.@(sxd|std|sda|sdd|odg|otg)' oodraw
  137. complete -f -X '!*.@(sxm|smf|mml|odf)' oomath
  138. complete -f -X '!*.odb' oobase
  139. complete -f -X '!*.rpm' rpm2cpio
  140. complete -f -X '!*.sqlite' sqlite3
  141. complete -f -X '!*.aux' bibtex
  142. # FINISH exclude -- do not remove this line
  143.  
  144. # start of section containing compspecs that can be handled within bash
  145.  
  146. # user commands see only users
  147. complete -u su usermod userdel passwd chage write chfn groups slay w sux
  148.  
  149. # group commands see only groups
  150. [ -n "$bash205" ] && complete -g groupmod groupdel newgrp 2>/dev/null
  151.  
  152. # bg completes with stopped jobs
  153. complete -A stopped -P '"%' -S '"' bg
  154.  
  155. # other job commands
  156. complete -j -P '"%' -S '"' fg jobs disown
  157.  
  158. # readonly and unset complete with shell variables
  159. complete -v readonly unset
  160.  
  161. # set completes with set options
  162. complete -A setopt set
  163.  
  164. # shopt completes with shopt options
  165. complete -A shopt shopt
  166.  
  167. # helptopics
  168. complete -A helptopic help
  169.  
  170. # unalias completes with aliases
  171. complete -a unalias
  172.  
  173. # bind completes with readline bindings (make this more intelligent)
  174. complete -A binding bind
  175.  
  176. # type and which complete on commands
  177. complete -c command type which
  178.  
  179. # builtin completes on builtins
  180. complete -b builtin
  181.  
  182. # start of section containing completion functions called by other functions
  183.  
  184. # This function checks whether we have a given program on the system.
  185. # No need for bulky functions in memory if we don't.
  186. #
  187. have()
  188. {
  189.     unset -v have
  190.     PATH=$PATH:/sbin:/usr/sbin:/usr/local/sbin type $1 &>/dev/null &&
  191.         have="yes"
  192. }
  193.  
  194. # use GNU sed if we have it, since its extensions are still used in our code
  195. #
  196. [ $USERLAND != GNU ] && have gsed && alias sed=gsed
  197.  
  198. # This function checks whether a given readline variable
  199. # is `on'.
  200. #
  201. _rl_enabled()
  202. {
  203.     [[ "$( bind -v )" = *$1+([[:space:]])on* ]]
  204. }
  205.  
  206. # This function shell-quotes the argument
  207. quote()
  208. {
  209.     echo \'${1//\'/\'\\\'\'}\' #'# Help vim syntax highlighting
  210. }
  211.  
  212. # This function quotes the argument in a way so that readline dequoting 
  213. # results in the original argument
  214. quote_readline()
  215. {
  216.     if [[ "${BASH_VERSINFO[0]}" -ge 4 ]] ; then
  217.         # This function isn't really necessary on bash 4
  218.         # See: http://lists.gnu.org/archive/html/bug-bash/2009-03/msg00155.html
  219.         echo "${1}"
  220.         return
  221.     fi
  222.     local t="${1//\\/\\\\}"
  223.     echo \'${t//\'/\'\\\'\'}\' #'# Help vim syntax highlighting
  224. }
  225.  
  226. # This function shell-dequotes the argument
  227. dequote()
  228. {
  229.     eval echo "$1"
  230. }
  231.  
  232. # Get the word to complete
  233. # This is nicer than ${COMP_WORDS[$COMP_CWORD]}, since it handles cases
  234. # where the user is completing in the middle of a word.
  235. # (For example, if the line is "ls foobar",
  236. # and the cursor is here -------->   ^
  237. # it will complete just "foo", not "foobar", which is what the user wants.)
  238. #
  239. #
  240. # Accepts an optional parameter indicating which characters out of
  241. # $COMP_WORDBREAKS should NOT be considered word breaks. This is useful
  242. # for things like scp where we want to return host:path and not only path.
  243. _get_cword()
  244. {
  245.     if [[ "${#COMP_WORDS[COMP_CWORD]}" -eq 0 ]] || [[ "$COMP_POINT" == "${#COMP_LINE}" ]]; then
  246.         printf "%s" "${COMP_WORDS[COMP_CWORD]}"
  247.     else
  248.         local i
  249.         local cur="$COMP_LINE"
  250.         local index="$COMP_POINT"
  251.         for (( i = 0; i <= COMP_CWORD; ++i )); do
  252.             while [[ "${#cur}" -ge ${#COMP_WORDS[i]} ]] && [[ "${cur:0:${#COMP_WORDS[i]}}" != "${COMP_WORDS[i]}" ]]; do
  253.                 cur="${cur:1}"
  254.                 index="$(( index - 1 ))"
  255.             done
  256.             if [[ "$i" -lt "$COMP_CWORD" ]]; then
  257.                 local old_size="${#cur}"
  258.                 cur="${cur#${COMP_WORDS[i]}}"
  259.                 local new_size="${#cur}"
  260.                 index="$(( index - old_size + new_size ))"
  261.             fi
  262.         done
  263.         
  264.         if [[ "${COMP_WORDS[COMP_CWORD]:0:${#cur}}" != "$cur" ]]; then
  265.             # We messed up! At least return the whole word so things 
  266.             # keep working
  267.             printf "%s" "${COMP_WORDS[COMP_CWORD]}"
  268.         else
  269.             printf "%s" "${cur:0:$index}"
  270.         fi
  271.     fi
  272. }
  273.  
  274. # This function performs file and directory completion. It's better than
  275. # simply using 'compgen -f', because it honours spaces in filenames.
  276. # If passed -d, it completes only on directories. If passed anything else,
  277. # it's assumed to be a file glob to complete on.
  278. #
  279. _filedir()
  280. {
  281.     local IFS=$'\t\n' xspec
  282.  
  283.     _expand || return 0
  284.  
  285.     local -a toks
  286.     local tmp
  287.     
  288.     # TODO: I've removed a "[ -n $tmp ] &&" before `echo $tmp',
  289.     #       and everything works again. If this bug
  290.     #       suddenly appears again (i.e. "cd /b<TAB>"
  291.     #       becomes "cd /"), remember to check for
  292.     #       other similar conditionals (here and
  293.     #       _filedir_xspec()). --David
  294.     # NOTE: The comment above has been moved outside of the subshell below, 
  295.     #       because quotes-in-comments-in-a-subshell cause errors on
  296.     #       bash-3.1.  See also: 
  297.     #       http://www.mail-archive.com/bug-bash@gnu.org/msg01667.html
  298.     toks=( ${toks[@]-} $(
  299.         compgen -d -- "$(quote_readline "$cur")" | {
  300.             while read -r tmp; do
  301.                 echo $tmp
  302.             done
  303.         }
  304.     ))
  305.     
  306.     if [[ "$1" != -d ]]; then
  307.         xspec=${1:+"!*.$1"}
  308.         toks=( ${toks[@]-} $(
  309.             compgen -f -X "$xspec" -- "$(quote_readline "$cur")" | {
  310.                 while read -r tmp; do
  311.                     [ -n $tmp ] && echo $tmp
  312.                 done
  313.             }
  314.         ))
  315.     fi
  316.  
  317.     COMPREPLY=( "${COMPREPLY[@]}" "${toks[@]}" )
  318. }
  319.  
  320. # This function tries to parse the output of $command --help
  321. #
  322. _parse_help() {
  323.     local cmd
  324.     cmd=$1
  325.     $cmd --help | \
  326.         grep -- "^[[:space:]]*-" | \
  327.         tr "," " " | \
  328.         awk '{print $1; if ($2 ~ /-.*/) { print $2 } }' | \
  329.         sed -e "s:=.*::g"
  330. }
  331.  
  332. # This function completes on signal names
  333. #
  334. _signals()
  335. {
  336.     local i
  337.  
  338.     # standard signal completion is rather braindead, so we need
  339.     # to hack around to get what we want here, which is to
  340.     # complete on a dash, followed by the signal name minus
  341.     # the SIG prefix
  342.     COMPREPLY=( $( compgen -A signal SIG${cur#-} ))
  343.     for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
  344.         COMPREPLY[i]=-${COMPREPLY[i]#SIG}
  345.     done
  346. }
  347.  
  348. # This function completes on configured network interfaces
  349. #
  350. _configured_interfaces()
  351. {
  352.     if [ -f /etc/debian_version ]; then
  353.         # Debian system
  354.         COMPREPLY=( $( sed -ne 's|^iface \([^ ]\+\).*$|\1|p' \
  355.                    /etc/network/interfaces ) )
  356.     elif [ -f /etc/SuSE-release ]; then
  357.         # SuSE system
  358.         COMPREPLY=( $( command ls \
  359.             /etc/sysconfig/network/ifcfg-* | \
  360.             sed -ne 's|.*ifcfg-\('$cur'.*\)|\1|p' ) )
  361.     elif [ -f /etc/pld-release ]; then
  362.         # PLD Linux
  363.         COMPREPLY=( $( command ls -B \
  364.             /etc/sysconfig/interfaces | \
  365.             sed -ne 's|.*ifcfg-\('$cur'.*\)|\1|p' ) )
  366.     else
  367.         # Assume Red Hat
  368.         COMPREPLY=( $( command ls \
  369.             /etc/sysconfig/network-scripts/ifcfg-* | \
  370.             sed -ne 's|.*ifcfg-\('$cur'.*\)|\1|p' ) )
  371.     fi
  372. }
  373.  
  374. # This function completes on available kernels
  375. #
  376. _kernel_versions()
  377. {
  378.     COMPREPLY=( $( command ls /lib/modules | grep "^$cur" ) )
  379. }
  380.  
  381. # This function completes on all available network interfaces
  382. # -a: restrict to active interfaces only
  383. # -w: restrict to wireless interfaces only
  384. #
  385. _available_interfaces()
  386. {
  387.     local cmd
  388.  
  389.     if [ "${1:-}" = -w ]; then
  390.         cmd="iwconfig"
  391.     elif [ "${1:-}" = -a ]; then
  392.         cmd="ifconfig"
  393.     else
  394.         cmd="ifconfig -a"
  395.     fi
  396.  
  397.     COMPREPLY=( $( eval $cmd 2>/dev/null | \
  398.         sed -ne 's|^\('$cur'[^[:space:][:punct:]]\{1,\}\).*$|\1|p') )
  399. }
  400.  
  401. # This function expands tildes in pathnames
  402. #
  403. _expand()
  404. {
  405.     # FIXME: Why was this here?
  406.     #[ "$cur" != "${cur%\\}" ] && cur="$cur\\"
  407.  
  408.     # Expand ~username type directory specifications.  We want to expand
  409.     # ~foo/... to /home/foo/... to avoid problems when $cur starting with
  410.     # a tilde is fed to commands and ending up quoted instead of expanded.
  411.  
  412.     if [[ "$cur" == \~*/* ]]; then
  413.         eval cur=$cur
  414.     elif [[ "$cur" == \~* ]]; then
  415.         cur=${cur#\~}
  416.         COMPREPLY=( $( compgen -P '~' -u $cur ) )
  417.         [ ${#COMPREPLY[@]} -eq 1 ] && eval COMPREPLY[0]=${COMPREPLY[0]}
  418.         return ${#COMPREPLY[@]}
  419.     fi
  420. }
  421.  
  422. # This function completes on process IDs.
  423. # AIX and Solaris ps prefers X/Open syntax.
  424. [ $UNAME = SunOS -o $UNAME = AIX ] &&
  425. _pids()
  426. {
  427.     COMPREPLY=( $( compgen -W '$( command ps -efo pid | sed 1d )' -- $cur ))
  428. } ||
  429. _pids()
  430. {
  431.     COMPREPLY=( $( compgen -W '$( command ps axo pid | sed 1d )' -- $cur ) )
  432. }
  433.  
  434. # This function completes on process group IDs.
  435. # AIX and SunOS prefer X/Open, all else should be BSD.
  436. [ $UNAME = SunOS -o $UNAME = AIX ] &&
  437. _pgids()
  438. {
  439.     COMPREPLY=( $( compgen -W '$( command ps -efo pgid | sed 1d )' -- $cur ))
  440. } ||
  441. _pgids()
  442. {
  443.     COMPREPLY=( $( compgen -W '$( command ps axo pgid | sed 1d )' -- $cur ))
  444. }
  445.  
  446. # This function completes on process names.
  447. # AIX and SunOS prefer X/Open, all else should be BSD.
  448. [ $UNAME = SunOS -o $UNAME = AIX ] &&
  449. _pnames()
  450. {
  451.     COMPREPLY=( $( compgen -W '$( command ps -efo comm | \
  452.                        sed -e 1d -e "s:.*/::" -e "s/^-//" \
  453.                        -e "s/^<defunct>$//")' \
  454.                        -- $cur ) )
  455. } ||
  456. _pnames()
  457. {
  458.     # FIXME: completes "[kblockd/0]" to "0". Previously it was completed
  459.     # to "kblockd" which isn't correct either. "kblockd/0" would be
  460.     # arguably most correct, but killall from psmisc 22 treats arguments
  461.     # containing "/" specially unless -r is given so that wouldn't quite
  462.     # work either. Perhaps it'd be best to not complete these to anything
  463.     # for now.
  464.     # Not using "ps axo comm" because under some Linux kernels, it
  465.     # truncates command names (see e.g. http://bugs.debian.org/497540#19)
  466.     COMPREPLY=( $( compgen -W '$( command ps axo command | \
  467.                        sed -e "1d; s/ .*//; s:.*/::; s/:$//;" \
  468.                            -e "s/^[[(-]//; s/[])]$//" \
  469.                        -e "s/^<defunct>$//")' \
  470.                        -- $cur ) )
  471. }
  472.  
  473. # This function completes on user IDs
  474. #
  475. _uids()
  476. {
  477.     if type getent &>/dev/null; then
  478.         COMPREPLY=( $( getent passwd | \
  479.                 awk -F: '{if ($3 ~ /^'$cur'/) print $3}' ) )
  480.     elif type perl &>/dev/null; then
  481.         COMPREPLY=( $( compgen -W '$( perl -e '"'"'while (($uid) = (getpwent)[2]) { print $uid . "\n" }'"'"' )' -- $cur ) )
  482.     else
  483.         # make do with /etc/passwd
  484.         COMPREPLY=( $( awk 'BEGIN {FS=":"} {if ($3 ~ /^'$cur'/) print $3}'\
  485.                 /etc/passwd ) )
  486.     fi
  487. }
  488.  
  489. # This function completes on group IDs
  490. #
  491. _gids()
  492. {
  493.     if type getent &>/dev/null; then
  494.         COMPREPLY=( $( getent group | \
  495.                 awk -F: '{if ($3 ~ /^'$cur'/) print $3}' ) )
  496.     elif type perl &>/dev/null; then
  497.         COMPREPLY=( $( compgen -W '$( perl -e '"'"'while (($gid) = (getgrent)[2]) { print $gid . "\n" }'"'"' )' -- $cur ) )
  498.     else
  499.         # make do with /etc/group
  500.         COMPREPLY=( $( awk 'BEGIN {FS=":"} {if ($3 ~ /^'$cur'/) print $3}'\
  501.                 /etc/group ) )
  502.     fi
  503. }
  504.  
  505. # This function completes on services
  506. #
  507. _services()
  508. {
  509.     local sysvdir famdir
  510.     [ -d /etc/rc.d/init.d ] && sysvdir=/etc/rc.d/init.d || sysvdir=/etc/init.d
  511.     famdir=/etc/xinetd.d
  512.     COMPREPLY=( $( builtin echo $sysvdir/!(*.rpm@(orig|new|save)|*~|functions)) )
  513.  
  514.     if [ -d $famdir ]; then
  515.         COMPREPLY=( "${COMPREPLY[@]}" $( builtin echo $famdir/!(*.rpm@(orig|new|save)|*~)) )
  516.     fi
  517.  
  518.     COMPREPLY=( $( compgen -W '${COMPREPLY[@]#@($sysvdir|$famdir)/}' -- $cur ) )
  519. }
  520.  
  521. # This function completes on modules
  522. #
  523. _modules()
  524. {
  525.     local modpath
  526.     modpath=/lib/modules/$1
  527.     COMPREPLY=( $( command ls -R $modpath | \
  528.             sed -ne 's/^\('$cur'.*\)\.k\?o\(\|.gz\)$/\1/p') )
  529. }
  530.  
  531. # This function completes on installed modules
  532. #
  533. _installed_modules()
  534. {
  535.     COMPREPLY=( $( compgen -W "$( /sbin/lsmod | \
  536.                   awk '{if (NR != 1) print $1}' )" -- $1 ) )
  537. }
  538.  
  539. # This function completes on user:group format
  540. #
  541. _usergroup()
  542. {
  543.     local IFS=$'\n'
  544.     cur=${cur//\\\\ / }
  545.     if [[ $cur = *@(\\:|.)* ]] && [ -n "$bash205" ]; then
  546.         user=${cur%%*([^:.])}
  547.         COMPREPLY=( $(compgen -P ${user/\\\\} -g -- ${cur##*[.:]}) )
  548.     elif [[ $cur = *:* ]] && [ -n "$bash205" ]; then
  549.         COMPREPLY=( $( compgen -g -- ${cur##*[.:]} ) )
  550.     else
  551.         COMPREPLY=( $( compgen -S : -u -- $cur ) )
  552.     fi
  553. }
  554.  
  555.  
  556. # Get real command.
  557. # - arg: $1  Command
  558. # - stdout:  Filename of command in PATH with possible symbolic links resolved.
  559. #            Empty string if command not found.
  560. # - return:  True (0) if command found, False (> 0) if not.
  561. _realcommand() {
  562.     type -P "$1" > /dev/null && {
  563.         if type -p realpath > /dev/null; then
  564.             realpath "$(type -P "$1")"
  565.         elif type -p readlink > /dev/null; then
  566.             readlink -f "$(type -P "$1")"
  567.         else
  568.             type -P "$1"
  569.         fi
  570.     }
  571. }
  572.  
  573.  
  574. # this function count the number of mandatory args
  575. #
  576. _count_args()
  577. {
  578.     args=1
  579.     for (( i=1; i < COMP_CWORD; i++ )); do
  580.         if [[ "${COMP_WORDS[i]}" != -* ]]; then
  581.             args=$(($args+1))
  582.         fi
  583.     done
  584. }
  585.  
  586. # This function complete on PCI IDs
  587. #
  588. _pci_ids()
  589. {
  590.     COMPREPLY=( ${COMPREPLY[@]:-} \
  591.         $( compgen -W "$( lspci -n | awk '{print $3}')" -- $cur ) )
  592. }
  593.  
  594. # This function complete on USB IDs
  595. #
  596. _usb_ids()
  597. {
  598.     COMPREPLY=( ${COMPREPLY[@]:-} \
  599.         $( compgen -W "$( lsusb | awk '{print $6}')" -- $cur ) )
  600. }
  601.  
  602. # start of section containing completion functions for bash built-ins
  603.  
  604. # bash alias completion
  605. #
  606. _alias()
  607. {
  608.     local cur
  609.  
  610.     COMPREPLY=()
  611.     cur=`_get_cword`
  612.  
  613.     case "$COMP_LINE" in
  614.     *[^=])
  615.         COMPREPLY=( $( compgen -A alias -- $cur ) )
  616.         ;;
  617.     *=)
  618.         COMPREPLY=( "$( alias ${cur%=} 2>/dev/null | \
  619.                  sed -e 's|^alias '$cur'\(.*\)$|\1|' )" )
  620.         ;;
  621.     esac
  622. }
  623. complete -F _alias $nospace alias
  624.  
  625. # bash export completion
  626. #
  627. _export()
  628. {
  629.     local cur
  630.  
  631.     COMPREPLY=()
  632.     cur=`_get_cword`
  633.  
  634.     case "$COMP_LINE" in
  635.     *=\$*)
  636.         COMPREPLY=( $( compgen -v -P '$' -- ${cur#*=\$} ) )
  637.         ;;
  638.     *[^=])
  639.         COMPREPLY=( $( compgen -v -S '=' -- $cur ) )
  640.         ;;
  641.     *=)
  642.         COMPREPLY=( "$( eval echo -n \"$`echo ${cur%=}`\" |
  643.             ( echo -n \'
  644.               sed -e 's/'\''/'\''\\\'\'''\''/g'
  645.               echo -n \' ) )" )
  646.         ;;
  647.     esac
  648. }
  649. complete -F _export $default $nospace export
  650.  
  651. # bash shell function completion
  652. #
  653. _function()
  654. {
  655.     local cur prev
  656.  
  657.     COMPREPLY=()
  658.     cur=`_get_cword`
  659.     prev=${COMP_WORDS[COMP_CWORD-1]}
  660.  
  661.     if [[ $1 == @(declare|typeset) ]]; then
  662.         if [ "$prev" = -f ]; then
  663.             COMPREPLY=( $( compgen -A function -- $cur ) )
  664.         elif [[ "$cur" == -* ]]; then
  665.             COMPREPLY=( $( compgen -W '-a -f -F -i -r -x -p' -- \
  666.                        $cur ) )
  667.         fi
  668.     elif [ $COMP_CWORD -eq 1 ]; then
  669.         COMPREPLY=( $( compgen -A function -- $cur ) )
  670.     else
  671.         COMPREPLY=( "() $( type -- ${COMP_WORDS[1]} | sed -e 1,2d )" )
  672.     fi
  673. }
  674. complete -F _function function declare typeset
  675.  
  676. # bash complete completion
  677. #
  678. _complete()
  679. {
  680.     local cur prev options
  681.  
  682.     COMPREPLY=()
  683.     cur=`_get_cword`
  684.     prev=${COMP_WORDS[COMP_CWORD-1]}
  685.  
  686.     case $prev in
  687.         -o)
  688.             options="default dirnames filenames"
  689.             [ -n "$bash205b" ] && options="$options nospace"
  690.             [ -n "$bash3" ] && options="$options bashdefault plusdirs"
  691.             COMPREPLY=( $( compgen -W "$options" -- $cur ) )
  692.             return 0
  693.             ;;
  694.  
  695.         -A)
  696.             COMPREPLY=( $( compgen -W 'alias arrayvar binding \
  697.                 builtin command directory disabled enabled \
  698.                 export file function group helptopic hostname \
  699.                 job keyword running service setopt shopt \
  700.                 signal stopped user variable' -- $cur ) )
  701.             return 0
  702.             ;;
  703.  
  704.         -C)
  705.             COMPREPLY=( $( compgen -A command -- $cur ) )
  706.             return 0
  707.             ;;
  708.         -F)
  709.             COMPREPLY=( $( compgen -A function -- $cur ) )
  710.             return 0
  711.             ;;
  712.         -@(p|r))
  713.             COMPREPLY=( $( complete -p | sed -e 's|.* ||' | \
  714.                     grep "^$cur" ) )
  715.             return 0
  716.             ;;
  717.  
  718.     esac
  719.  
  720.     if [[ "$cur" == -* ]]; then
  721.         # relevant options completion
  722.         options="-a -b -c -d -e -f -g -j -k -s -v -u -A -G -W -P -S -X -F -C"
  723.         [ -n "$bash205" ] && options="$options -o"
  724.         COMPREPLY=( $( compgen -W "$options" -- $cur ) )
  725.     else
  726.         COMPREPLY=( $( compgen -A command -- $cur ) )
  727.     fi
  728. }
  729. complete -F _complete complete
  730.  
  731. # start of section containing completion functions for external programs
  732.  
  733. # a little help for FreeBSD ports users
  734. [ $UNAME = FreeBSD ] && complete -W 'index search fetch fetch-list \
  735.     extract patch configure build install reinstall \
  736.     deinstall clean clean-depends kernel buildworld' make
  737.  
  738. # This completes on a list of all available service scripts for the
  739. # 'service' command and/or the SysV init.d directory, followed by
  740. # that script's available commands
  741. #
  742. { have service || [ -d /etc/init.d/ ]; } &&
  743. _service()
  744. {
  745.     local cur sysvdir
  746.  
  747.     COMPREPLY=()
  748.     prev=${COMP_WORDS[COMP_CWORD-1]}
  749.     cur=`_get_cword`
  750.  
  751.     # don't complete for things like killall, ssh and mysql if it's
  752.     # the standalone command, rather than the init script
  753.     [[ ${COMP_WORDS[0]} != @(*init.d/!(functions|~)|service) ]] && return 0
  754.  
  755.     # don't complete past 2nd token
  756.     [ $COMP_CWORD -gt 2 ] && return 0
  757.  
  758.     [ -d /etc/rc.d/init.d ] && sysvdir=/etc/rc.d/init.d \
  759.                 || sysvdir=/etc/init.d
  760.  
  761.     if [[ $COMP_CWORD -eq 1 ]] && [[ $prev == "service" ]]; then
  762.         _services
  763.     else
  764.         COMPREPLY=( $( compgen -W '`sed -ne "y/|/ /; \
  765.                 s/^.*Usage.*{\(.*\)}.*$/\1/p" \
  766.                 $sysvdir/${prev##*/} 2>/dev/null`' -- $cur ) )
  767.     fi
  768.  
  769.     return 0
  770. } &&
  771. complete -F _service service
  772. [ -d /etc/init.d/ ] && complete -F _service $default \
  773.     $(for i in /etc/init.d/*; do echo ${i##*/}; done)
  774.  
  775. # chown(1) completion
  776. #
  777. _chown()
  778. {
  779.     local cur
  780.     cur=`_get_cword`
  781.  
  782.     # options completion
  783.     if [[ "$cur" == -* ]]; then
  784.         COMPREPLY=( $( compgen -W '-c -h -f -R -v --changes \
  785.         --dereference --no-dereference --from= --silent --quiet \
  786.         --reference= --recursive --verbose --help --version' -- $cur ) )
  787.     else
  788.         _count_args
  789.  
  790.         case $args in
  791.             1)
  792.                 _usergroup
  793.                 ;;
  794.             *)
  795.                 _filedir
  796.                 ;;
  797.         esac
  798.     fi
  799. }
  800. complete -F _chown $filenames chown
  801.  
  802. # chgrp(1) completion
  803. #
  804. _chgrp()
  805. {
  806.     local cur prev
  807.  
  808.     COMPREPLY=()
  809.     cur=`_get_cword`
  810.     cur=${cur//\\\\/}
  811.     prev=${COMP_WORDS[COMP_CWORD-1]}
  812.  
  813.     # options completion
  814.     if [[ "$cur" == -* ]]; then
  815.         COMPREPLY=( $( compgen -W '-c -h -f -R -v --changes \
  816.         --dereference --no-dereference --silent --quiet \
  817.         --reference= --recursive --verbose --help --version' -- $cur ) )
  818.         return 0
  819.     fi
  820.  
  821.     # first parameter on line or first since an option?
  822.     if [ $COMP_CWORD -eq 1 ] && [[ "$cur" != -* ]] || \
  823.        [[ "$prev" == -* ]] && [ -n "$bash205" ]; then
  824.         local IFS=$'\n'
  825.         COMPREPLY=( $( compgen -g $cur 2>/dev/null ) )
  826.     else
  827.         _filedir || return 0
  828.     fi
  829.  
  830.     return 0
  831. }
  832. complete -F _chgrp $filenames chgrp
  833.  
  834. # umount(8) completion. This relies on the mount point being the third
  835. # space-delimited field in the output of mount(8)
  836. #
  837. _umount()
  838. {
  839.     local cur IFS=$'\n'
  840.  
  841.     COMPREPLY=()
  842.     cur=`_get_cword`
  843.  
  844.     COMPREPLY=( $( compgen -W '$( mount | cut -d" " -f 3 )' -- $cur ) )
  845.  
  846.     return 0
  847. }
  848. complete -F _umount $dirnames umount
  849.  
  850. # mount(8) completion. This will pull a list of possible mounts out of
  851. # /etc/{,v}fstab, unless the word being completed contains a ':', which
  852. # would indicate the specification of an NFS server. In that case, we
  853. # query the server for a list of all available exports and complete on
  854. # that instead.
  855. #
  856. _mount()
  857. {
  858.     local cur i sm host
  859.  
  860.     COMPREPLY=()
  861.     cur=`_get_cword`
  862.     [[ "$cur" == \\ ]] && cur="/"
  863.  
  864.     for i in {,/usr}/{,s}bin/showmount; do [ -x $i ] && sm=$i && break; done
  865.  
  866.     if [ -n "$sm" ] && [[ "$cur" == *:* ]]; then
  867.         COMPREPLY=( $( $sm -e ${cur%%:*} | sed 1d | \
  868.                    grep ^${cur#*:} | awk '{print $1}' ) )
  869.     elif [[ "$cur" == //* ]]; then
  870.         host=${cur#//}
  871.         host=${host%%/*}
  872.         if [ -n "$host" ]; then
  873.             COMPREPLY=( $( compgen -W "$( echo $( smbclient -d 0 -NL $host 2>/dev/null|
  874.             sed -ne '/^['"$'\t '"']*Sharename/,/^$/p' |
  875.             sed -ne '3,$s|^[^A-Za-z]*\([^'"$'\t '"']*\).*$|//'$host'/\1|p' ) )" -- "$cur" ) )
  876.         fi
  877.     elif [ -r /etc/vfstab ]; then
  878.         # Solaris
  879.         COMPREPLY=( $( awk '! /^[ \t]*#/ {if ($3 ~ /\//) print $3}' \
  880.                 /etc/vfstab | grep "^$cur" ) )
  881.     elif [ ! -e /etc/fstab ]; then
  882.         # probably Cygwin
  883.         COMPREPLY=( $( mount | awk '! /^[ \t]*#/ {if ($3 ~ /\//) print $3}' \
  884.                  | grep "^$cur" ) )
  885.     else
  886.         # probably Linux
  887.         COMPREPLY=( $( awk '! /^[ \t]*#/ {if ($2 ~ /\//) print $2}' \
  888.                 /etc/fstab | grep "^$cur" ) )
  889.     fi
  890.  
  891.     return 0
  892. }
  893. complete -F _mount $default $dirnames mount
  894.  
  895. # Linux rmmod(8) completion. This completes on a list of all currently
  896. # installed kernel modules.
  897. #
  898. have rmmod && {
  899. _rmmod()
  900. {
  901.     local cur
  902.  
  903.     COMPREPLY=()
  904.     cur=`_get_cword`
  905.  
  906.     _installed_modules "$cur"
  907.     return 0
  908. }
  909. complete -F _rmmod rmmod
  910.  
  911. # Linux insmod(8), modprobe(8) and modinfo(8) completion. This completes on a
  912. # list of all available modules for the version of the kernel currently
  913. # running.
  914. #
  915. _insmod()
  916. {
  917.     local cur prev modpath
  918.  
  919.     COMPREPLY=()
  920.     cur=`_get_cword`
  921.     prev=${COMP_WORDS[COMP_CWORD-1]}
  922.  
  923.     # behave like lsmod for modprobe -r
  924.     if [ $1 = "modprobe" ] &&
  925.        [ "${COMP_WORDS[1]}" = "-r" ]; then
  926.         _installed_modules "$cur"
  927.         return 0
  928.     fi
  929.  
  930.     # do filename completion if we're giving a path to a module
  931.     if [[ "$cur" == */* ]]; then
  932.         _filedir '@(?(k)o?(.gz))'
  933.         return 0
  934.     fi
  935.  
  936.     if [ $COMP_CWORD -gt 1 ] &&
  937.        [[ "${COMP_WORDS[COMP_CWORD-1]}" != -* ]]; then
  938.         # do module parameter completion
  939.         COMPREPLY=( $( /sbin/modinfo -p ${COMP_WORDS[1]} 2>/dev/null | \
  940.                awk '{if ($1 ~ /^parm:/ && $2 ~ /^'$cur'/) { print $2 } \
  941.             else if ($1 !~ /:/ && $1 ~ /^'$cur'/) { print $1 }}' ) )
  942.     else
  943.         _modules $(uname -r)
  944.     fi
  945.  
  946.     return 0
  947. }
  948. complete -F _insmod $filenames insmod modprobe modinfo
  949. }
  950.  
  951. # man(1) completion
  952. #
  953. [ $USERLAND = GNU -o $UNAME = Darwin \
  954.   -o $UNAME = FreeBSD -o $UNAME = SunOS -o $UNAME = Cygwin \
  955.   -o $UNAME = OpenBSD ] &&
  956. _man()
  957. {
  958.     local cur prev sect manpath manext mansect uname
  959.  
  960.     manext="@([0-9lnp]|[0-9][px]|man)?(.@(gz|bz2|lzma))"
  961.     mansect="@([0-9lnp]|[0-9][px])"
  962.  
  963.     COMPREPLY=()
  964.     cur=`_get_cword`
  965.     prev=${COMP_WORDS[COMP_CWORD-1]}
  966.     
  967.     if [[ "$prev" == -l ]]; then
  968.         _filedir $manext
  969.         return 0
  970.     fi
  971.  
  972.     _expand || return 0
  973.  
  974.     # file based completion if parameter contains /
  975.     if [[ "$cur" == */* ]]; then
  976.         _filedir $manext
  977.         return 0
  978.     fi
  979.  
  980.     uname=$( uname -s )
  981.     if [[ $uname == @(Linux|GNU|GNU/*|FreeBSD|Cygwin|CYGWIN_*) ]]; then
  982.         manpath=$( manpath 2>/dev/null || command man --path )
  983.     else
  984.         manpath=$MANPATH
  985.     fi
  986.  
  987.     if [ -z "$manpath" ]; then
  988.         COMPREPLY=( $( compgen -c -- $cur ) )
  989.         return 0
  990.     fi
  991.  
  992.     # determine manual section to search
  993.     [[ "$prev" == $mansect ]] && sect=$prev || sect='*'
  994.  
  995.     manpath=$manpath:
  996.     if [ -n "$cur" ]; then
  997.         manpath="${manpath//://*man$sect/$cur* } ${manpath//://*cat$sect/$cur* }"
  998.     else
  999.         manpath="${manpath//://*man$sect/ } ${manpath//://*cat$sect/ }"
  1000.     fi
  1001.  
  1002.     # redirect stderr for when path doesn't exist
  1003.     COMPREPLY=( $( eval command ls "$manpath" 2>/dev/null ) )
  1004.     # weed out directory path names and paths to man pages
  1005.     COMPREPLY=( ${COMPREPLY[@]##*/?(:)} )
  1006.     # strip suffix from man pages
  1007.     COMPREPLY=( ${COMPREPLY[@]%.@(gz|bz2|lzma)} )
  1008.     COMPREPLY=( $( compgen -W '${COMPREPLY[@]%.*}' -- "${cur//\\\\/}" ) )
  1009.  
  1010.     if [[ "$prev" != $mansect ]]; then
  1011.         # File based completion for the rest, prepending ./ if needed
  1012.         # (man 1.6f needs that for man pages in current dir)
  1013.         local start=${#COMPREPLY[@]}
  1014.         _filedir $manext
  1015.         for (( i=$start; i < ${#COMPREPLY[@]}; i++ )); do
  1016.             [[ ${COMPREPLY[i]} == */* ]] || COMPREPLY[i]=./${COMPREPLY[i]}
  1017.         done
  1018.     fi
  1019.  
  1020.     return 0
  1021. }
  1022. [ $USERLAND = GNU -o $UNAME = Darwin \
  1023.   -o $UNAME = FreeBSD -o $UNAME = SunOS -o $UNAME = Cygwin \
  1024.   -o $UNAME = OpenBSD ] && \
  1025. complete -F _man $filenames man apropos whatis
  1026.  
  1027. # renice(8) completion
  1028. #
  1029. _renice()
  1030. {
  1031.     local command cur curopt i
  1032.  
  1033.     COMPREPLY=()
  1034.     cur=`_get_cword`
  1035.     command=$1
  1036.  
  1037.     i=0
  1038.     # walk back through command line and find last option
  1039.     while [ $i -le $COMP_CWORD -a ${#COMPREPLY[@]} -eq 0 ]; do
  1040.         curopt=${COMP_WORDS[COMP_CWORD-$i]}
  1041.         case "$curopt" in
  1042.         -u)
  1043.             COMPREPLY=( $( compgen -u -- $cur ) )
  1044.             ;;
  1045.         -g)
  1046.             _pgids
  1047.             ;;
  1048.         -p|$command)
  1049.             _pids
  1050.             ;;
  1051.         esac
  1052.         i=$(( ++i ))
  1053.     done
  1054. }
  1055. complete -F _renice renice
  1056.  
  1057. # kill(1) completion
  1058. #
  1059. _kill()
  1060. {
  1061.     local cur
  1062.  
  1063.     COMPREPLY=()
  1064.     cur=`_get_cword`
  1065.  
  1066.     if [ $COMP_CWORD -eq 1 ] && [[ "$cur" == -* ]]; then
  1067.         # return list of available signals
  1068.         _signals
  1069.     else
  1070.         # return list of available PIDs
  1071.         _pids
  1072.     fi
  1073. }
  1074. complete -F _kill kill
  1075.  
  1076. # killall(1) (Linux and FreeBSD) and pkill(1) completion.
  1077. #
  1078. [ $UNAME = Linux -o $UNAME = FreeBSD ] || have pkill &&
  1079. _killall()
  1080. {
  1081.     local cur
  1082.  
  1083.     COMPREPLY=()
  1084.     cur=`_get_cword`
  1085.  
  1086.     if [ $COMP_CWORD -eq 1 ] && [[ "$cur" == -* ]]; then
  1087.         _signals
  1088.     else
  1089.         _pnames
  1090.     fi
  1091.  
  1092.     return 0
  1093. }
  1094. [ $UNAME = Linux -o $UNAME = FreeBSD ] && complete -F _killall killall
  1095. have pkill && complete -F _killall pkill
  1096.  
  1097. # pgrep(1) completion.
  1098. #
  1099. [ $UNAME = Linux ] || have pgrep &&
  1100. _pgrep()
  1101. {
  1102.     local cur
  1103.  
  1104.     COMPREPLY=()
  1105.     cur=`_get_cword`
  1106.  
  1107.     _pnames
  1108.  
  1109.     return 0
  1110. }
  1111. have pgrep && complete -F _pgrep pgrep
  1112.  
  1113. # Linux pidof(8) completion.
  1114. [ $UNAME = Linux ] && complete -F _pgrep pidof
  1115.  
  1116. # GNU find(1) completion. This makes heavy use of ksh style extended
  1117. # globs and contains Linux specific code for completing the parameter
  1118. # to the -fstype option.
  1119. #
  1120. _find()
  1121. {
  1122.     local cur prev i exprfound onlyonce
  1123.  
  1124.     COMPREPLY=()
  1125.     cur=`_get_cword`
  1126.     prev=${COMP_WORDS[COMP_CWORD-1]}
  1127.  
  1128.     case "$prev" in
  1129.     -@(max|min)depth)
  1130.         COMPREPLY=( $( compgen -W '0 1 2 3 4 5 6 7 8 9' -- $cur ) )
  1131.         return 0
  1132.         ;;
  1133.     -?(a|c)newer|-fls|-fprint?(0|f)|-?(i)?(l)name|-?(i)wholename)
  1134.         _filedir
  1135.         return 0
  1136.         ;;
  1137.     -fstype)
  1138.         # this is highly non-portable
  1139.         [ -e /proc/filesystems ] &&
  1140.         COMPREPLY=( $( cut -d$'\t' -f 2 /proc/filesystems | \
  1141.                 grep "^$cur" ) )
  1142.         return 0
  1143.         ;;
  1144.     -gid)
  1145.         _gids
  1146.         return 0
  1147.         ;;
  1148.     -group)
  1149.         if [ -n "$bash205" ]; then
  1150.             COMPREPLY=( $( compgen -g -- $cur 2>/dev/null) )
  1151.         fi
  1152.         return 0
  1153.         ;;
  1154.     -?(x)type)
  1155.         COMPREPLY=( $( compgen -W 'b c d p f l s' -- $cur ) )
  1156.         return 0
  1157.         ;;
  1158.     -uid)
  1159.         _uids
  1160.         return 0
  1161.         ;;
  1162.     -user)
  1163.         COMPREPLY=( $( compgen -u -- $cur ) )
  1164.         return 0
  1165.         ;;
  1166.     -exec|-ok)
  1167.         COMP_WORDS=(COMP_WORDS[0] $cur)
  1168.         COMP_CWORD=1
  1169.         _command
  1170.         return 0
  1171.         ;;
  1172.     -[acm]min|-[acm]time|-?(i)?(l)?(whole)name|-inum|-?(i)path|-?(i)regex| \
  1173.     -links|-perm|-size|-used|-printf)
  1174.         # do nothing, just wait for a parameter to be given
  1175.         return 0
  1176.         ;;
  1177.     esac
  1178.  
  1179.     _expand || return 0
  1180.  
  1181.     # set exprfound to 1 if there is already an expression present
  1182.     for i in ${COMP_WORDS[@]}; do
  1183.         [[ "$i" = [-\(\),\!]* ]] && exprfound=1 && break
  1184.     done
  1185.  
  1186.     # handle case where first parameter is not a dash option
  1187.     if [ "$exprfound" != 1 ] && [[ "$cur" != [-\(\),\!]* ]]; then
  1188.         _filedir -d
  1189.         return 0
  1190.     fi
  1191.  
  1192.     # complete using basic options
  1193.     COMPREPLY=( $( compgen -W '-daystart -depth -follow -help -maxdepth \
  1194.             -mindepth -mount -noleaf -version -xdev -amin -anewer \
  1195.             -atime -cmin -cnewer -ctime -empty -false -fstype \
  1196.             -gid -group -ilname -iname -inum -ipath -iregex \
  1197.             -wholename \
  1198.             -links -lname -mmin -mtime -name -newer -nouser \
  1199.             -nogroup -perm -regex -size -true -type -uid -used \
  1200.             -user -xtype -exec -fls -fprint -fprint0 -fprintf -ok \
  1201.             -print -print0 -printf -prune -ls -wholename -iwholename' -- $cur ) )
  1202.  
  1203.     # this removes any options from the list of completions that have
  1204.     # already been specified somewhere on the command line, as long as
  1205.     # these options can only be used once (in a word, "options", in
  1206.     # opposition to "tests" and "actions", as in the find(1) manpage).
  1207.     onlyonce=' -daystart -depth -follow -help -maxdepth -mindepth -mount \
  1208.            -noleaf -version -xdev '
  1209.     COMPREPLY=( $( echo "${COMP_WORDS[@]}" | \
  1210.                (while read -d ' ' i; do
  1211.                 [ "$i" == "" ] ||
  1212.                 [ "${onlyonce/ ${i%% *} / }" == "$onlyonce" ] &&
  1213.                 continue
  1214.                 # flatten array with spaces on either side,
  1215.                 # otherwise we cannot grep on word boundaries of
  1216.                 # first and last word
  1217.                 COMPREPLY=" ${COMPREPLY[@]} "
  1218.                 # remove word from list of completions
  1219.                 COMPREPLY=( ${COMPREPLY/ ${i%% *} / } )
  1220.             done
  1221.             echo "${COMPREPLY[@]}")
  1222.           ) )
  1223.  
  1224.     _filedir
  1225.  
  1226.     return 0
  1227. }
  1228. complete -F _find $filenames find
  1229.  
  1230. # Linux iwconfig(8) completion
  1231. #
  1232. [ $UNAME = Linux ] && have iwconfig &&
  1233. _iwconfig()
  1234. {
  1235.     local cur prev
  1236.  
  1237.     COMPREPLY=()
  1238.     cur=`_get_cword`
  1239.     prev=${COMP_WORDS[COMP_CWORD-1]}
  1240.  
  1241.     case $prev in
  1242.         mode)
  1243.             COMPREPLY=( $( compgen -W 'managed ad-hoc master \
  1244.                 repeater secondary monitor' -- $cur ) )
  1245.             return 0
  1246.             ;;
  1247.         essid)
  1248.             COMPREPLY=( $( compgen -W 'on off any' -- $cur ) )
  1249.             if [ -n "${COMP_IWLIST_SCAN:-}" ]; then
  1250.                 COMPREPLY=( "${COMPREPLY[@]}" \
  1251.                     $( iwlist ${COMP_WORDS[1]} scan | \
  1252.                     awk -F '"' '/ESSID/ {print $2}' | \
  1253.                     grep "^$cur" ))
  1254.             fi
  1255.             return 0
  1256.             ;;
  1257.         nwid)
  1258.             COMPREPLY=( $( compgen -W 'on off' -- $cur ) )
  1259.             return 0
  1260.             ;;
  1261.         channel)
  1262.             COMPREPLY=( $( iwlist ${COMP_WORDS[1]} channel | \
  1263.                 awk '/^[[:space:]]*Channel/ {print $2}' | \
  1264.                 grep "^$cur" ) )
  1265.             return 0
  1266.             ;;
  1267.  
  1268.         freq)
  1269.             COMPREPLY=( $( iwlist ${COMP_WORDS[1]} channel | \
  1270.                 awk '/^[[:space:]]*Channel/ {print $4"G"}' | \
  1271.                 grep "^$cur" ) )
  1272.             return 0
  1273.             ;;
  1274.         ap)
  1275.             COMPREPLY=( $( compgen -W 'on off any' -- $cur ) )
  1276.             if [ -n "${COMP_IWLIST_SCAN:-}" ]; then
  1277.                 COMPREPLY=( "${COMPREPLY[@]}" \
  1278.                     $( iwlist ${COMP_WORDS[1]} scan | \
  1279.                     awk -F ': ' '/Address/ {print $2}' | \
  1280.                     grep "^$cur" ) )
  1281.             fi
  1282.             return 0
  1283.             ;;
  1284.         rate)
  1285.             COMPREPLY=( $( compgen -W 'auto fixed' -- $cur ) )
  1286.             COMPREPLY=( "${COMPREPLY[@]}" \
  1287.                 $( iwlist ${COMP_WORDS[1]} rate | \
  1288.                 awk '/^[[:space:]]*[0-9]/ {print $1"M"}' | \
  1289.                 grep "^$cur" ) )
  1290.             return 0
  1291.             ;;
  1292.         rts)
  1293.             COMPREPLY=( $( compgen -W 'auto fixed off' -- $cur ) )
  1294.             return 0
  1295.             ;;
  1296.         frag)
  1297.             COMPREPLY=( $( compgen -W 'auto fixed off' -- $cur ) )
  1298.             return 0
  1299.             ;;
  1300.         key)
  1301.             COMPREPLY=( $( compgen -W 'off on open restricted' -- $cur ) )
  1302.             return 0
  1303.             ;;
  1304.         enc)
  1305.             COMPREPLY=( $( compgen -W 'off on open restricted' -- $cur ) )
  1306.             return 0
  1307.             ;;
  1308.         power)
  1309.             COMPREPLY=( $( compgen -W 'period timeout off on' -- $cur ) )
  1310.             return 0
  1311.             ;;
  1312.         txpower)
  1313.             COMPREPLY=( $( compgen -W 'off on auto' -- $cur ) )
  1314.             return 0
  1315.             ;;
  1316.         retry)
  1317.             COMPREPLY=( $( compgen -W 'limit lifetime' -- $cur ) )
  1318.             return 0
  1319.             ;;
  1320.     esac
  1321.  
  1322.     if [ $COMP_CWORD -eq 1 ]; then
  1323.         if [[ "$cur" == -* ]]; then
  1324.             COMPREPLY=( $( compgen -W '--help --version' -- $cur ) )
  1325.         else
  1326.             _available_interfaces -w
  1327.         fi
  1328.     else
  1329.         COMPREPLY=( $( compgen -W 'essid nwid mode freq channel sens mode \
  1330.             ap nick rate rts frag enc key power txpower commit' -- $cur ) )
  1331.     fi
  1332.  
  1333. } &&
  1334. complete -F _iwconfig iwconfig
  1335.  
  1336. # Linux iwlist(8) completion
  1337. #
  1338. [ $UNAME = Linux ] && have iwlist &&
  1339. _iwlist()
  1340. {
  1341.     local cur prev
  1342.  
  1343.     COMPREPLY=()
  1344.     cur=`_get_cword`
  1345.     prev=${COMP_WORDS[COMP_CWORD-1]}
  1346.  
  1347.     if [ $COMP_CWORD -eq 1 ]; then
  1348.         if [[ "$cur" == -* ]]; then
  1349.             COMPREPLY=( $( compgen -W '--help --version' -- $cur ) )
  1350.         else
  1351.             _available_interfaces -w
  1352.         fi
  1353.     else
  1354.         COMPREPLY=( $( compgen -W 'scan scanning freq frequency \
  1355.             channel rate bit bitrate key enc encryption power \
  1356.             txpower retry ap accesspoint peers event' -- $cur ) )
  1357.     fi
  1358. } &&
  1359. complete -F _iwlist iwlist
  1360.  
  1361. # Linux iwspy(8) completion
  1362. #
  1363. [ $UNAME = Linux ] && have iwspy &&
  1364. _iwspy()
  1365. {
  1366.     local cur
  1367.  
  1368.     COMPREPLY=()
  1369.     cur=`_get_cword`
  1370.  
  1371.     if [ $COMP_CWORD -eq 1 ]; then
  1372.         if [[ "$cur" == -* ]]; then
  1373.             COMPREPLY=( $( compgen -W '--help --version' -- $cur ) )
  1374.         else
  1375.             _available_interfaces -w
  1376.         fi
  1377.     else
  1378.         COMPREPLY=( $( compgen -W 'setthr getthr off' -- $cur ) )
  1379.     fi
  1380. } &&
  1381. complete -F _iwspy iwspy
  1382.  
  1383. # Linux iwpriv(8) completion
  1384. #
  1385. [ $UNAME = Linux ] && have iwpriv &&
  1386. _iwpriv()
  1387. {
  1388.     local cur prev
  1389.  
  1390.     COMPREPLY=()
  1391.     cur=`_get_cword`
  1392.     prev=${COMP_WORDS[COMP_CWORD-1]}
  1393.  
  1394.     case "$prev" in
  1395.         roam)
  1396.             COMPREPLY=( $( compgen -W 'on off' -- $cur ) )
  1397.             return 0
  1398.             ;;
  1399.         port)
  1400.             COMPREPLY=( $( compgen -W 'ad-hoc managed' -- $cur ) )
  1401.             return 0
  1402.             ;;
  1403.     esac
  1404.  
  1405.     if [ $COMP_CWORD -eq 1 ]; then
  1406.         if [[ "$cur" == -* ]]; then
  1407.             COMPREPLY=( $( compgen -W '--help --version' -- $cur ) )
  1408.         else
  1409.             _available_interfaces -w
  1410.         fi
  1411.     else
  1412.         COMPREPLY=( $( compgen -W '--all roam port' -- $cur ) )
  1413.     fi
  1414. } &&
  1415. complete -F _iwpriv iwpriv
  1416.  
  1417. # Red Hat & Debian GNU/Linux if{up,down} completion
  1418. #
  1419. [ $USERLAND = GNU ] && { have ifup || have ifdown; } &&
  1420. _ifupdown()
  1421. {
  1422.     local cur
  1423.  
  1424.     COMPREPLY=()
  1425.     cur=`_get_cword`
  1426.  
  1427.     if [ $COMP_CWORD -eq 1 ]; then
  1428.         _configured_interfaces
  1429.         COMPREPLY=( $(compgen -W '${COMPREPLY[@]}' -- "$cur") )
  1430.        fi
  1431.  
  1432.        return 0
  1433. } &&
  1434. complete -F _ifupdown ifup ifdown
  1435. [ $USERLAND = GNU ] && have ifstatus && complete -F _ifupdown ifstatus
  1436.  
  1437. # Linux ipsec(8) completion (for FreeS/WAN)
  1438. #
  1439. [ $UNAME = Linux ] && have ipsec &&
  1440. _ipsec()
  1441. {
  1442.     local cur
  1443.  
  1444.     COMPREPLY=()
  1445.     cur=`_get_cword`
  1446.  
  1447.  
  1448.     if [ $COMP_CWORD -eq 1 ]; then
  1449.         COMPREPLY=( $( compgen -W 'auto barf eroute klipsdebug look \
  1450.                        manual pluto ranbits rsasigkey \
  1451.                        setup showdefaults showhostkey spi \
  1452.                        spigrp tncfg whack' -- $cur ) )
  1453.         return 0
  1454.     fi
  1455.  
  1456.     case ${COMP_WORDS[1]} in
  1457.     auto)
  1458.         COMPREPLY=( $( compgen -W '--asynchronous --up --add --delete \
  1459.                        --replace --down --route --unroute \
  1460.                        --ready --status --rereadsecrets' \
  1461.                     -- $cur ) )
  1462.         ;;
  1463.     manual)
  1464.         COMPREPLY=( $( compgen -W '--up --down --route --unroute \
  1465.                        --union' -- $cur ) )
  1466.         ;;
  1467.     ranbits)
  1468.         COMPREPLY=( $( compgen -W '--quick --continuous --bytes' \
  1469.                       -- $cur ) )
  1470.         ;;
  1471.     setup)
  1472.         COMPREPLY=( $( compgen -W '--start --stop --restart' -- $cur ) )
  1473.         ;;
  1474.  
  1475.     *)
  1476.         ;;
  1477.     esac
  1478.  
  1479.     return 0
  1480. } &&
  1481. complete -F _ipsec ipsec
  1482.  
  1483. # Postfix completion.
  1484. #
  1485. have postfix && {
  1486. # postfix(1)
  1487. #
  1488. _postfix()
  1489. {
  1490.     local cur prev
  1491.  
  1492.     cur=`_get_cword`
  1493.     prev=${COMP_WORDS[COMP_CWORD-1]}
  1494.  
  1495.     if [[ $cur == '-' ]]; then
  1496.         COMPREPLY=(-c -D -v)
  1497.         return 0
  1498.     fi
  1499.     if [[ $prev == '-c' ]]; then
  1500.         _filedir -d
  1501.         return 0
  1502.     fi
  1503.     if [[ $prev == '-D' ]]; then
  1504.         COMPREPLY=( $( compgen -W 'start' -- "`_get_cword`" ) )
  1505.         return 0
  1506.     fi
  1507.     COMPREPLY=( $( compgen -W 'start stop reload abort flush check' -- \
  1508.         "`_get_cword`" ) )
  1509. }
  1510. complete -F _postfix postfix
  1511.  
  1512. # postalias(1) and postmap(1)
  1513. #
  1514. _postmap()
  1515. {
  1516.     local cur prev len idx
  1517.  
  1518.     cur=`_get_cword`
  1519.     prev=${COMP_WORDS[COMP_CWORD-1]}
  1520.  
  1521.     if [[ $cur == '-' ]]; then
  1522.         COMPREPLY=(-N -f -i -n -o -p -r -v -w -c -d -q)
  1523.         return 0
  1524.     fi
  1525.     if [[ $prev == '-c' ]]; then
  1526.         _filedir -d
  1527.         return 0
  1528.     fi
  1529.     if [[ $prev == -[dq] ]]; then
  1530.         return 0
  1531.     fi
  1532.  
  1533.     if [[ "$cur" == *:* ]]; then
  1534.                COMPREPLY=( $( compgen -f -- ${cur#*:} ) )
  1535.     else
  1536.         len=${#cur}
  1537.         idx=0
  1538.         for pval in $( /usr/sbin/postconf -m ); do
  1539.             if [[ "$cur" == "${pval:0:$len}" ]]; then
  1540.                 COMPREPLY[$idx]="$pval:"
  1541.                 idx=$(($idx+1))
  1542.             fi
  1543.         done
  1544.         if [[ $idx -eq 0 ]]; then
  1545.             COMPREPLY=( $( compgen -f -- "$cur" ) )
  1546.         fi
  1547.     fi
  1548.     return 0
  1549. }
  1550. complete -F _postmap postmap postalias
  1551.  
  1552. # postcat(1)
  1553. #
  1554. _postcat()
  1555. {
  1556.     local cur prev pval len idx qfile
  1557.  
  1558.     cur=`_get_cword`
  1559.     prev=${COMP_WORDS[COMP_CWORD-1]}
  1560.  
  1561.     if [[ $cur == '-' ]]; then
  1562.         COMPREPLY=(-c -q -v)
  1563.         return 0
  1564.     fi
  1565.     if [[ $prev == '-c' ]]; then
  1566.         _filedir -d
  1567.         return 0
  1568.     fi
  1569.  
  1570.     qfile=0
  1571.     for idx in "${COMP_WORDS[@]}"; do
  1572.         [[ "$idx" = -q ]] && qfile=1 && break
  1573.     done
  1574.     if [[ $qfile == 1 ]]; then
  1575.         len=${#cur}
  1576.         idx=0
  1577.         for pval in $( mailq | \
  1578.             sed -e '1d; $d; /^[^0-9A-Z]\|^$/d; s/[* !].*$//' ); do
  1579.             if [[ "$cur" == "${pval:0:$len}" ]]; then
  1580.                 COMPREPLY[$idx]=$pval
  1581.                 idx=$(($idx+1))
  1582.             fi
  1583.         done
  1584.         return 0
  1585.     else
  1586.         _filedir
  1587.         return 0
  1588.     fi
  1589. }
  1590. complete -F _postcat postcat
  1591.  
  1592. # postconf(1)
  1593. #
  1594. _postconf()
  1595. {
  1596.     local cur prev pval len idx eqext
  1597.  
  1598.     cur=`_get_cword`
  1599.     prev=${COMP_WORDS[COMP_CWORD-1]}
  1600.     if [[ $cur == '-' ]]; then
  1601.         COMPREPLY=(-c -d -e -h -m -l -n -v)
  1602.         return 0
  1603.     fi
  1604.     if [[ $prev == '-c' ]]; then
  1605.         _filedir -d
  1606.         return 0
  1607.     fi
  1608.     if [[ $prev == '-e' ]]; then
  1609.         cur=${cur#[\"\']}
  1610.         eqext='='
  1611.     fi
  1612.     len=${#cur}
  1613.     idx=0
  1614.     for pval in $( /usr/sbin/postconf | cut -d ' ' -f 1 ); do
  1615.         if [[ "$cur" == "${pval:0:$len}" ]]; then
  1616.             COMPREPLY[$idx]="$pval$eqext"
  1617.             idx=$(($idx+1))
  1618.         fi
  1619.     done
  1620.     return 0
  1621. }
  1622. complete -F _postconf postconf
  1623.  
  1624. # postsuper(1)
  1625. #
  1626. _postsuper()
  1627. {
  1628.     local cur prev pval len idx
  1629.  
  1630.     cur=`_get_cword`
  1631.     prev=${COMP_WORDS[COMP_CWORD-1]}
  1632.  
  1633.     if [[ $cur == '-' ]]; then
  1634.         COMPREPLY=(-c -d -h -H -p -r -s -v)
  1635.         return 0
  1636.     fi
  1637.     case $prev in
  1638.     -[dr])
  1639.         len=${#cur}
  1640.         idx=0
  1641.         for pval in $( echo ALL; mailq | \
  1642.             sed -e '1d; $d; /^[^0-9A-Z]\|^$/d; s/[* !].*$//' ); do
  1643.             if [[ "$cur" == "${pval:0:$len}" ]]; then
  1644.                 COMPREPLY[$idx]=$pval
  1645.                 idx=$(($idx+1))
  1646.             fi
  1647.         done
  1648.         return 0
  1649.         ;;
  1650.     -h)
  1651.         len=${#cur}
  1652.         idx=0
  1653.         for pval in $( echo ALL; mailq | \
  1654.             sed -e '1d; $d; /^[^0-9A-Z]\|^$/d; s/[* ].*$//; /!$/d' ); do
  1655.             if [[ "$cur" == "${pval:0:$len}" ]]; then
  1656.                 COMPREPLY[$idx]=$pval
  1657.                 idx=$(($idx+1))
  1658.             fi
  1659.         done
  1660.         return 0
  1661.         ;;
  1662.     -H)
  1663.         len=${#cur}
  1664.         idx=0
  1665.         for pval in $( echo ALL; mailq | \
  1666.             sed -e '1d; $d; /^[^0-9A-Z]\|^$/d; /^[0-9A-Z]*[* ]/d; s/!.*$//' ); do
  1667.             if [[ "$cur" == "${pval:0:$len}" ]]; then
  1668.                 COMPREPLY[$idx]=$pval
  1669.                 idx=$(($idx+1))
  1670.             fi
  1671.         done
  1672.         return 0
  1673.         ;;
  1674.     esac
  1675.     COMPREPLY=( $( compgen -W 'hold incoming active deferred' -- $cur ) )
  1676.     return 0
  1677. }
  1678. complete -F _postsuper postsuper
  1679. }
  1680.  
  1681. # cvs(1) completion
  1682. #
  1683. have cvs && {
  1684. set_prefix()
  1685. {
  1686.     [ -z ${prefix:-} ] || prefix=${cur%/*}/
  1687.     [ -r ${prefix:-}CVS/Entries ] || prefix=""
  1688. }
  1689.  
  1690. get_entries()
  1691. {
  1692.     local IFS=$'\n'
  1693.     [ -r ${prefix:-}CVS/Entries ] && \
  1694.     entries=$(cut -d/ -f2 -s ${prefix:-}CVS/Entries)
  1695. }
  1696.  
  1697. get_modules()
  1698. {
  1699.     if [ -n "$prefix" ]; then
  1700.         COMPREPLY=( $( command ls -d ${cvsroot}/${prefix}/!(CVSROOT) ) )
  1701.     else
  1702.         COMPREPLY=( $( command ls -d ${cvsroot}/!(CVSROOT) ) )
  1703.     fi
  1704. }
  1705.  
  1706. _cvs()
  1707. {
  1708.     local cur count mode i cvsroot cvsroots pwd
  1709.     local -a flags miss files entries changed newremoved
  1710.  
  1711.     COMPREPLY=()
  1712.     cur=`_get_cword`
  1713.  
  1714.     count=0
  1715.     for i in "${COMP_WORDS[@]}"; do
  1716.         [ $count -eq $COMP_CWORD ] && break
  1717.         # Last parameter was the CVSROOT, now go back to mode selection
  1718.         if [ "${COMP_WORDS[((count))]}" == "$cvsroot" -a "$mode" == "cvsroot" ]; then
  1719.             mode=""
  1720.         fi
  1721.         if [ -z "$mode" ]; then
  1722.             case $i in
  1723.             -d)
  1724.                 mode=cvsroot
  1725.                 cvsroot=${COMP_WORDS[((count+1))]}
  1726.                 ;;
  1727.             @(ad?(d)|new))
  1728.                 mode=add
  1729.                 ;;
  1730.             @(adm?(in)|rcs))
  1731.                 mode=admin
  1732.                 ;;
  1733.             ann?(notate))
  1734.                 mode=annotate
  1735.                 ;;
  1736.             @(checkout|co|get))
  1737.                 mode=checkout
  1738.                 ;;
  1739.             @(com?(mit)|ci))
  1740.                 mode=commit
  1741.                 ;;
  1742.             di?(f?(f)))
  1743.                 mode=diff
  1744.                 ;;
  1745.             ex?(p?(ort)))
  1746.                 mode=export
  1747.                 ;;
  1748.             ?(un)edit)
  1749.                 mode=$i
  1750.                 ;;
  1751.             hi?(s?(tory)))
  1752.                 mode=history
  1753.                 ;;
  1754.             im?(p?(ort)))
  1755.                 mode=import
  1756.                 ;;
  1757.             re?(l?(ease)))
  1758.                 mode=release
  1759.                 ;;
  1760.             ?(r)log)
  1761.                 mode=log
  1762.                 ;;
  1763.             @(rdiff|patch))
  1764.                 mode=rdiff
  1765.                 ;;
  1766.             @(remove|rm|delete))
  1767.                 mode=remove
  1768.                 ;;
  1769.             @(rtag|rfreeze))
  1770.                 mode=rtag
  1771.                 ;;
  1772.             st?(at?(us)))
  1773.                 mode=status
  1774.                 ;;
  1775.             @(tag|freeze))
  1776.                 mode=tag
  1777.                 ;;
  1778.             up?(d?(ate)))
  1779.                 mode=update
  1780.                 ;;
  1781.             *)
  1782.                 ;;
  1783.             esac
  1784.         elif [[ "$i" = -* ]]; then
  1785.             flags=( "${flags[@]}" $i )
  1786.         fi
  1787.         count=$((++count))
  1788.     done
  1789.  
  1790.     case "$mode" in
  1791.     add)
  1792.         if [[ "$cur" != -* ]]; then
  1793.             set_prefix
  1794.             if [ $COMP_CWORD -gt 1 -a -r ${prefix:-}CVS/Entries ]; then
  1795.                 get_entries
  1796.                 [ -z "$cur" ] && \
  1797.                 files=$( command ls -Ad !(CVS) ) || \
  1798.                 files=$( command ls -d ${cur}* 2>/dev/null )
  1799.                 for i in "${entries[@]}"; do
  1800.                     files=( ${files[@]/#$i//} )
  1801.                 done
  1802.                 COMPREPLY=( $( compgen -X '*~' -W '${files[@]}' -- \
  1803.                            $cur ) )
  1804.             fi
  1805.         else
  1806.             COMPREPLY=( $( compgen -W '-k -m' -- $cur ) )
  1807.         fi
  1808.         ;;
  1809.     admin)
  1810.         if [[ "$cur" = -* ]]; then
  1811.             COMPREPLY=( $( compgen -W '-i -a -A -e -b -c -k -l -u \
  1812.                            -L -U -m -M -n -N -o -q -I \
  1813.                            -s -t -t- -T -V -x -z' -- \
  1814.                     $cur ) )
  1815.         fi
  1816.         ;;
  1817.     annotate)
  1818.         if [[ "$cur" = -* ]]; then
  1819.             COMPREPLY=( $( compgen -W '-D -F -f -l -R -r' -- $cur ) )
  1820.         else
  1821.             get_entries
  1822.             COMPREPLY=( $( compgen -W '${entries[@]}' -- $cur ) )
  1823.         fi
  1824.         ;;
  1825.     checkout)
  1826.         if [[ "$cur" != -* ]]; then
  1827.             [ -z "$cvsroot" ] && cvsroot=$CVSROOT
  1828.             COMPREPLY=( $( cvs -d "$cvsroot" co -c 2> /dev/null | \
  1829.                     awk '{print $1}' ) )
  1830.             COMPREPLY=( $( compgen -W '${COMPREPLY[@]}' -- $cur ) )
  1831.         else
  1832.             COMPREPLY=( $( compgen -W '-A -N -P -R -c -f -l -n -p \
  1833.                           -s -r -D -d -k -j' -- $cur ) )
  1834.         fi
  1835.         ;;
  1836.     commit)
  1837.         set_prefix
  1838.  
  1839.         if [[ "$cur" != -* ]] && [ -r ${prefix:-}CVS/Entries ]; then
  1840.             # if $COMP_CVS_REMOTE is not null, 'cvs commit' will
  1841.             # complete on remotely checked-out files (requires
  1842.             # passwordless access to the remote repository
  1843.             if [ -n "${COMP_CVS_REMOTE:-}" ]; then
  1844.                 # this is the least computationally intensive
  1845.                 # way found so far, but other changes
  1846.                 # (something other than changed/removed/new)
  1847.                 # may be missing
  1848.                 changed=( $( cvs -q diff --brief 2>&1 | \
  1849.                 sed -ne 's/^Files [^ ]* and \([^ ]*\) differ$/\1/p' ) )
  1850.                 newremoved=( $( cvs -q diff --brief 2>&1 | \
  1851.                 sed -ne 's/^cvs diff: \([^ ]*\) .*, no comparison available$/\1/p' ) )
  1852.                 COMPREPLY=( $( compgen -W '${changed[@]:-} \
  1853.                            ${newremoved[@]:-}' -- $cur ) )
  1854.             else
  1855.                 COMPREPLY=( $(compgen $default -- "$cur") )
  1856.             fi
  1857.         else
  1858.             COMPREPLY=( $( compgen -W '-n -R -l -f -F -m -r' -- \
  1859.                        $cur ) )
  1860.         fi
  1861.         ;;
  1862.     cvsroot)
  1863.         if [ -r ~/.cvspass ]; then
  1864.             # Ugly escaping because of bash treating ':' specially
  1865.             cvsroots=$( sed 's/^[^ ]* //; s/:/\\:/g' ~/.cvspass )
  1866.             COMPREPLY=( $( compgen -W '$cvsroots' -- $cur ) )
  1867.         fi
  1868.         ;;
  1869.     export)
  1870.         if [[ "$cur" != -* ]]; then
  1871.             [ -z "$cvsroot" ] && cvsroot=$CVSROOT
  1872.             COMPREPLY=( $( cvs -d "$cvsroot" co -c | awk '{print $1}' ) )
  1873.             COMPREPLY=( $( compgen -W '${COMPREPLY[@]}' -- $cur ) )
  1874.         else
  1875.             COMPREPLY=( $( compgen -W '-N -f -l -R -n \
  1876.                           -r -D -d -k' -- $cur ) )
  1877.         fi
  1878.         ;;
  1879.     diff)
  1880.         if [[ "$cur" == -* ]]; then
  1881.             _longopt diff
  1882.         else
  1883.             get_entries
  1884.             COMPREPLY=( $( compgen -W '${entries[@]:-}' -- $cur ) )
  1885.         fi
  1886.         ;;
  1887.     remove)
  1888.         if [[ "$cur" != -* ]]; then
  1889.             set_prefix
  1890.             if [ $COMP_CWORD -gt 1 -a -r ${prefix:-}CVS/Entries ]; then
  1891.                 get_entries
  1892.                 # find out what files are missing
  1893.                 for i in "${entries[@]}"; do
  1894.                     [ ! -r "$i" ] && miss=( "${miss[@]}" $i )
  1895.                 done
  1896.                 COMPREPLY=( $(compgen -W '${miss[@]:-}' -- $cur) )
  1897.             fi
  1898.         else
  1899.             COMPREPLY=( $( compgen -W '-f -l -R' -- $cur ) )
  1900.         fi
  1901.         ;;
  1902.     import)
  1903.         if [[ "$cur" != -* ]]; then
  1904.             # starts with same algorithm as checkout
  1905.             [ -z "$cvsroot" ] && cvsroot=$CVSROOT
  1906.             prefix=${cur%/*}
  1907.             if [ -r ${cvsroot}/${prefix} ]; then
  1908.                 get_modules
  1909.                 COMPREPLY=( ${COMPREPLY[@]#$cvsroot} )
  1910.                 COMPREPLY=( ${COMPREPLY[@]#\/} )
  1911.             fi
  1912.             pwd=$( pwd )
  1913.             pwd=${pwd##*/}
  1914.             COMPREPLY=( $( compgen -W '${COMPREPLY[@]} $pwd' -- \
  1915.                        $cur ) )
  1916.         else
  1917.             COMPREPLY=( $( compgen -W '-d -k -I -b -m -W' -- $cur ))
  1918.         fi
  1919.         ;;
  1920.     update)
  1921.         if [[ "$cur" = -* ]]; then
  1922.             COMPREPLY=( $( compgen -W '-A -P -C -d -f -l -R -p \
  1923.                            -k -r -D -j -I -W' -- \
  1924.                            $cur ) )
  1925.         fi
  1926.         ;;
  1927.     "")
  1928.         COMPREPLY=( $( compgen -W 'add admin annotate checkout ci co \
  1929.                        commit diff delete edit export \
  1930.                        freeze get history import log new \
  1931.                        patch rcs rdiff release remove \
  1932.                        rfreeze rlog rm rtag stat status \
  1933.                        tag unedit up update -H -Q -q -b \
  1934.                        -d -e -f -l -n -t -r -v -w -x -z \
  1935.                        --help --version' -- $cur ) )
  1936.         ;;
  1937.     *)
  1938.         ;;
  1939.     esac
  1940.  
  1941.     return 0
  1942. }
  1943. complete -F _cvs $default cvs
  1944. }
  1945.  
  1946. have rpm && {
  1947. # helper functions for rpm completion
  1948. #
  1949. _rpm_installed_packages()
  1950. {
  1951.     local ver nodig="$1" nosig="$2"
  1952.  
  1953.     if [ -r /var/log/rpmpkgs -a \
  1954.         /var/log/rpmpkgs -nt /var/lib/rpm/Packages ]; then
  1955.         # using RHL 7.2 or later - this is quicker than querying the DB
  1956.         COMPREPLY=( $( sed -ne \
  1957.         's|^\('$cur'[^[:space:]]*\)-[^[:space:]-]\+-[^[:space:]-]\+\.rpm$|\1|p' \
  1958.                 /var/log/rpmpkgs ) )
  1959.     else
  1960.         _rpm_nodigsig
  1961.         COMPREPLY=( $( rpm -qa $nodig $nosig --qf='%{NAME} ' "$cur*" ) )
  1962.     fi
  1963. }
  1964.  
  1965. _rpm_groups()
  1966. {
  1967.     local IFS=$'\t'
  1968.     # remove trailing backslash, or grep will complain
  1969.     cur=${cur%"\\"}
  1970.     COMPREPLY=( $( rpm -qa $nodig $nosig --queryformat '%{group}\n' | \
  1971.                grep "^$cur" ) )
  1972.     # backslash escape spaces and translate newlines to tabs
  1973.     COMPREPLY=( $( echo "${COMPREPLY[@]}" | sed 's/ /\\ /g' | tr '\n' '\t' ) )
  1974. }
  1975.  
  1976. _rpm_nodigsig()
  1977. {
  1978.     if [ -z "$nodig" -a -z "$nosig" ]; then
  1979.         local rpmver
  1980.     
  1981.         rpmver=$(rpm --version)
  1982.         rpmver=${rpmver##* }
  1983.  
  1984.         if [[ "$rpmver" > "4.0.4" ]]; then
  1985.             nodig="--nodigest"
  1986.         fi
  1987.         if [[ "$rpmver" > "4.0.99" ]]; then
  1988.             nosig="--nosignature"
  1989.         fi
  1990.     fi
  1991. }
  1992.  
  1993. # rpm(8) completion
  1994. #
  1995. _rpm()
  1996. {
  1997.     local cur prev nodig nosig
  1998.  
  1999.     COMPREPLY=()
  2000.     cur=`_get_cword`
  2001.     prev=${COMP_WORDS[COMP_CWORD-1]}
  2002.     nodig=""
  2003.     nosig=""
  2004.     _rpm_nodigsig
  2005.  
  2006.     if [ $COMP_CWORD -eq 1 ]; then
  2007.         # first parameter on line
  2008.         case "$cur" in
  2009.         -b*)
  2010.             COMPREPLY=( $( compgen -W '-ba -bb -bc -bi -bl -bp -bs'\
  2011.                        -- $cur ) )
  2012.             ;;
  2013.         -t*)
  2014.             COMPREPLY=( $( compgen -W '-ta -tb -tc -ti -tl -tp -ts'\
  2015.                        -- $cur ) )
  2016.             ;;
  2017.         --*)
  2018.             COMPREPLY=( $( compgen -W '--help --version --initdb \
  2019.             --checksig --recompile --rebuild --resign --addsign \
  2020.             --rebuilddb --showrc --setperms --setugids --tarbuild \
  2021.             --eval --install --upgrade --query --freshen --erase \
  2022.             --verify --querytags --rmsource --rmspec --clean \
  2023.             --import' -- $cur ) )
  2024.             ;;
  2025.         *)
  2026.             COMPREPLY=( $( compgen -W '-b -e -E -F -i -q -t -U -V' \
  2027.                        -- $cur ) )
  2028.             ;;
  2029.         esac
  2030.  
  2031.     return 0
  2032.     fi
  2033.  
  2034.     case "$prev" in
  2035.     --@(@(db|exclude)path|prefix|relocate|root))
  2036.         _filedir -d
  2037.         return 0
  2038.         ;;
  2039.     --eval|-E)
  2040.         # get a list of macros
  2041.         COMPREPLY=( $( rpm --showrc | sed -ne \
  2042.         's/^-\?[0-9]\+[:=][[:space:]]\+\('${cur#%}'[^[:space:](]*\).*/\1/p' ) )
  2043.         COMPREPLY=( "${COMPREPLY[@]/#/%}" )
  2044.         return 0
  2045.         ;;
  2046.     --pipe)
  2047.         COMPREPLY=( $( compgen -c -- $cur ) )
  2048.         return 0
  2049.         ;;
  2050.     --rcfile)
  2051.         _filedir
  2052.         return 0
  2053.         ;;
  2054.     --specfile)
  2055.         # complete on .spec files
  2056.         _filedir spec
  2057.         return 0
  2058.         ;;
  2059.     --whatprovides)
  2060.         if [[ "$cur" == */* ]]; then
  2061.             _filedir
  2062.         else
  2063.         # complete on capabilities
  2064.             COMPREPLY=( $( rpm -qa $nodig $nosig --queryformat \
  2065.                     '%{providename}\n' | grep "^$cur" ) )
  2066.         fi
  2067.         return 0
  2068.         ;;
  2069.     --whatrequires)
  2070.         # complete on capabilities
  2071.         COMPREPLY=( $( rpm -qa $nodig $nosig --queryformat \
  2072.                 '%{requirename}\n' | grep "^$cur" ) )
  2073.         return 0
  2074.         ;;
  2075.     --target)
  2076.         COMPREPLY=( $( compgen -W "$( command rpm --showrc | sed -ne \
  2077.         's/^\s*compatible\s\+build\s\+archs\s*:\s*\(.*\)/\1/ p' )" -- $cur ) )
  2078.         return 0
  2079.         ;;
  2080.     esac
  2081.  
  2082.     case "${COMP_WORDS[1]}" in
  2083.     -@([iFU]*|-install|-freshen|-upgrade))
  2084.         if [[ "$cur" == -* ]]; then
  2085.             COMPREPLY=( $( compgen -W '--percent --force --test \
  2086.             --replacepkgs --replacefiles --root --excludedocs \
  2087.             --includedocs --noscripts --rcfile --ignorearch \
  2088.             --dbpath --prefix --ignoreos --nodeps --allfiles \
  2089.             --ftpproxy --ftpport --justdb --httpproxy --httpport \
  2090.             --noorder --relocate --badreloc --notriggers \
  2091.             --excludepath --ignoresize --oldpackage --define \
  2092.             --eval --pipe --queryformat --repackage --nosuggests \
  2093.             --nodigest --nosignature' -- $cur ) )
  2094.         else
  2095.             _filedir 'rpm'
  2096.         fi
  2097.         ;;
  2098.     -@(e|-erase))
  2099.         if [[ "$cur" == -* ]]; then
  2100.             COMPREPLY=( $( compgen -W '--allmatches --noscripts \
  2101.             --notriggers --nodeps --test --repackage' -- $cur ) )
  2102.         else
  2103.             _rpm_installed_packages "$nodig" "$nosig"
  2104.         fi
  2105.         ;;
  2106.     -@(q*|-query))
  2107.         # check whether we're doing file completion
  2108.         if [ "${COMP_LINE#* -*([^ -])f}" != "$COMP_LINE" ]; then
  2109.             if [[ "$cur" == -* ]]; then
  2110.             COMPREPLY=( $( compgen -W '--scripts --root \
  2111.                 --rcfile --requires --ftpport --ftpproxy \
  2112.                 --httpproxy --httpport --provides --triggers \
  2113.                 --dump --changelog --dbpath \
  2114.                 --last --filesbypkg \
  2115.                 --info --list --state \
  2116.                 --docfiles --configfiles --queryformat \
  2117.                 --conflicts --obsoletes \
  2118.                 --nodigest --nosignature \
  2119.                 --suggests --enhances \
  2120.                 --triggerscripts' -- $cur ) )
  2121.             else
  2122.             _filedir
  2123.             fi
  2124.         elif [ "${COMP_LINE#* -*([^ -])g}" != "$COMP_LINE" ]; then
  2125.             _rpm_groups
  2126.         elif [ "${COMP_LINE#* -*([^ -])p}" != "$COMP_LINE" ]; then
  2127.             # uninstalled package completion
  2128.             if [[ "$cur" == -* ]]; then
  2129.                 COMPREPLY=( $( compgen -W '--scripts --root \
  2130.                 --rcfile --whatprovides --whatrequires \
  2131.                 --requires --triggeredby --ftpport --ftpproxy \
  2132.                 --httpproxy --httpport --provides --triggers \
  2133.                 --dump --changelog --dbpath --filesbypkg \
  2134.                 --define --eval --pipe --showrc --info --list \
  2135.                 --state --docfiles --configfiles --queryformat\
  2136.                 --conflicts --obsoletes --nodigest \
  2137.                 --nosignature' -- $cur ) )
  2138.             else
  2139.                 _filedir 'rpm'
  2140.             fi
  2141.         else
  2142.             # installed package completion
  2143.             if [[ "$cur" == -* ]]; then
  2144.                 COMPREPLY=( $( compgen -W '--scripts --root \
  2145.                 --rcfile --whatprovides --whatrequires \
  2146.                 --requires --triggeredby --ftpport --ftpproxy \
  2147.                 --httpproxy --httpport --provides --triggers \
  2148.                 --dump --changelog --dbpath --specfile \
  2149.                 --querybynumber --last --filesbypkg --define \
  2150.                 --eval --pipe --showrc --info --list --state \
  2151.                 --docfiles --configfiles --queryformat \
  2152.                 --conflicts --obsoletes --pkgid --hdrid \
  2153.                 --fileid --tid --nodigest --nosignature \
  2154.                 --triggerscripts' -- $cur ) )
  2155.             elif [ "${COMP_LINE#* -*([^ -])a}" == "$COMP_LINE" ]; then
  2156.                 _rpm_installed_packages "$nodig" "$nosig"
  2157.             fi
  2158.         fi
  2159.         ;;
  2160.     -@(K*|-checksig))
  2161.         if [[ "$cur" == -* ]]; then
  2162.             COMPREPLY=( $( compgen -W '--nopgp --nogpg --nomd5 \
  2163.                     --nodigest --nosignature' -- $cur ) )
  2164.         else
  2165.             _filedir 'rpm'
  2166.         fi
  2167.         ;;
  2168.     -@([Vy]*|-verify))
  2169.         if [[ "$cur" == -* ]]; then
  2170.             COMPREPLY=( $( compgen -W '--root --rcfile --dbpath \
  2171.             --nodeps --nogroup --nolinkto --nomode --nomtime \
  2172.             --nordev --nouser --nofiles --noscripts --nomd5 \
  2173.             --querytags --specfile --whatrequires --whatprovides \
  2174.             --nodigest --nosignature' -- $cur ) )
  2175.         # check whether we're doing file completion
  2176.         elif [ "${COMP_LINE#* -*([^ -])f}" != "$COMP_LINE" ]; then
  2177.             _filedir
  2178.         elif [ "${COMP_LINE#* -*([^ -])g}" != "$COMP_LINE" ]; then
  2179.             _rpm_groups
  2180.         elif [ "${COMP_LINE#* -*([^ -])p}" != "$COMP_LINE" ]; then
  2181.             _filedir 'rpm'
  2182.         else
  2183.             _rpm_installed_packages "$nodig" "$nosig"
  2184.         fi
  2185.         ;;
  2186.     -[bt]*)
  2187.         if [[ "$cur" == -* ]]; then
  2188.             COMPREPLY=( $( compgen -W '--short-circuit --timecheck \
  2189.             --clean --rmsource --rmspec --test --sign --buildroot \
  2190.             --target --nobuild --nodeps --nodirtokens' -- $cur ) )
  2191.         elif [[ ${COMP_WORDS[1]} == -b* ]]; then
  2192.             _filedir 'spec'
  2193.         else
  2194.             _filedir '@(tgz|tar.@(gz|bz2|lzma))'
  2195.         fi
  2196.         ;;
  2197.     --re@(build|compile))
  2198.         if [[ "$cur" == -* ]]; then
  2199.             COMPREPLY=( $( compgen -W '--nodeps --rmsource \
  2200.               --rmspec --sign --nodirtokens --target' -- $cur ) )
  2201.         else
  2202.             _filedir '?(no)src.rpm'
  2203.         fi
  2204.         ;;
  2205.     --tarbuild)
  2206.         _filedir '@(tgz|tar.@(gz|bz2|lzma))'
  2207.         ;;
  2208.     --@(re|add)sign)
  2209.         _filedir 'rpm'
  2210.         ;;
  2211.     --set@(perms|gids))
  2212.         _rpm_installed_packages "$nodig" "$nosig"
  2213.         ;;
  2214.     --@(clean|rms@(ource|pec)))
  2215.         if [[ "$cur" == -* ]]; then
  2216.             COMPREPLY=( $( compgen -W '--clean --rmsource \
  2217.                     --rmspec' -- $cur ) )
  2218.         else
  2219.             _filedir 'spec'
  2220.         fi
  2221.         ;;
  2222.     --@(import|dbpath|root))
  2223.         if [[ "$cur" == -* ]]; then
  2224.             COMPREPLY=( $( compgen -W '--import --dbpath --root' \
  2225.                     -- $cur ) )
  2226.         else
  2227.             _filedir
  2228.         fi
  2229.         ;;
  2230.     esac
  2231.  
  2232.     return 0
  2233. }
  2234. complete -F _rpm $filenames rpm rpmbuild
  2235. }
  2236.  
  2237. # Debian apt-get(8) completion.
  2238. #
  2239. have apt-get &&
  2240. _apt_get()
  2241. {
  2242.     local cur prev special i
  2243.  
  2244.     COMPREPLY=()
  2245.     cur=`_get_cword`
  2246.     prev=${COMP_WORDS[COMP_CWORD-1]}
  2247.  
  2248.     for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
  2249.         if [[ ${COMP_WORDS[i]} == @(install|remove|autoremove|purge|source|build-dep) ]]; then
  2250.             special=${COMP_WORDS[i]}
  2251.         fi
  2252.     done
  2253.  
  2254.     if [ -n "$special" ]; then
  2255.         case $special in
  2256.         remove|autoremove|purge)
  2257.             if [ -f /etc/debian_version ]; then
  2258.                 # Debian system
  2259.                 COMPREPLY=( $( _comp_dpkg_installed_packages \
  2260.                         $cur ) )
  2261.             else
  2262.                 # assume RPM based
  2263.                 _rpm_installed_packages
  2264.             fi
  2265.             return 0
  2266.             ;;
  2267.         *)
  2268.             COMPREPLY=( $( apt-cache pkgnames $cur 2> /dev/null ) )
  2269.             return 0
  2270.             ;;
  2271.  
  2272.         esac
  2273.     fi
  2274.  
  2275.     case "$prev" in
  2276.         -@(c|-config-file))
  2277.               _filedir
  2278.              return 0
  2279.              ;;
  2280.  
  2281.         -@(t|-target-release|-default-release))
  2282.              COMPREPLY=( $( apt-cache policy | \
  2283.                     grep "release.o=Debian,a=$cur" | \
  2284.                     sed -e "s/.*a=\(\w*\).*/\1/" | uniq 2> /dev/null) )
  2285.              return 0
  2286.              ;;
  2287.  
  2288.     esac
  2289.  
  2290.     if [[ "$cur" == -* ]]; then
  2291.  
  2292.         COMPREPLY=( $( compgen -W '-d -f -h -v -m -q -s -y \
  2293.                 -u -t -b -c -o --download-only --fix-broken \
  2294.                 --help --version --ignore-missing \
  2295.                 --fix-missing --no-download --quiet --simulate \
  2296.                 --just-print --dry-run --recon --no-act --yes \
  2297.                 --assume-yes --show-upgraded --only-source \
  2298.                 --compile --build --ignore-hold \
  2299.                 --target-release --no-upgrade --force-yes \
  2300.                 --print-uris --purge --reinstall \
  2301.                 --list-cleanup --default-release \
  2302.                 --trivial-only --no-remove --diff-only \
  2303.                 --no-install-recommends \
  2304.                 --tar-only --config-file --option --auto-remove' -- $cur ) )
  2305.     else
  2306.  
  2307.         COMPREPLY=( $( compgen -W 'update upgrade dselect-upgrade \
  2308.                 dist-upgrade install remove purge source build-dep \
  2309.                 check clean autoclean autoremove' -- $cur ) )
  2310.  
  2311.     fi
  2312.  
  2313.  
  2314.     return 0
  2315. } &&
  2316. complete -F _apt_get $filenames apt-get
  2317.  
  2318. # Debian apt-cache(8) completion.
  2319. #
  2320. have apt-cache &&
  2321. _apt_cache()
  2322. {
  2323.     local cur prev special i
  2324.  
  2325.     COMPREPLY=()
  2326.     cur=`_get_cword`
  2327.     prev=${COMP_WORDS[COMP_CWORD-1]}
  2328.  
  2329.  
  2330.     if [ "$cur" != show ]; then
  2331.         for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
  2332.         if [[ ${COMP_WORDS[i]} == @(add|depends|dotty|madison|policy|rdepends|show?(pkg|src|)) ]]; then
  2333.             special=${COMP_WORDS[i]}
  2334.         fi
  2335.         done
  2336.     fi
  2337.  
  2338.  
  2339.     if [ -n "$special" ]; then
  2340.         case $special in
  2341.         add)
  2342.             _filedir
  2343.             return 0
  2344.             ;;
  2345.  
  2346.         showsrc)
  2347.             COMPREPLY=( $( apt-cache dumpavail | \
  2348.                             grep "^Source: $cur" | sort | \
  2349.                             uniq | cut -f2 -d" " ) )
  2350.             return 0
  2351.             ;;
  2352.         
  2353.          *)
  2354.             COMPREPLY=( $( apt-cache pkgnames $cur 2> /dev/null ) )
  2355.             return 0
  2356.             ;;
  2357.  
  2358.         esac
  2359.     fi
  2360.  
  2361.  
  2362.     case "$prev" in
  2363.          -@(c|p|s|-config-file|-@(pkg|src)-cache))
  2364.              _filedir
  2365.              return 0
  2366.              ;;
  2367.          search)
  2368.              if [[ "$cur" != -* ]]; then
  2369.                 return 0
  2370.              fi
  2371.              ;;
  2372.     esac
  2373.  
  2374.     if [[ "$cur" == -* ]]; then
  2375.  
  2376.         COMPREPLY=( $( compgen -W '-h -v -p -s -q -i -f -a -g -c \
  2377.                 -o --help --version --pkg-cache --src-cache \
  2378.                 --quiet --important --full --all-versions \
  2379.                 --no-all-versions --generate --no-generate \
  2380.                 --names-only --all-names --recurse \
  2381.                 --config-file --option --installed' -- $cur ) )
  2382.     else
  2383.  
  2384.         COMPREPLY=( $( compgen -W 'add gencaches show showpkg showsrc \
  2385.                 stats dump dumpavail unmet search search \
  2386.                 depends rdepends pkgnames dotty xvcg \
  2387.                 policy madison' -- $cur ) )
  2388.  
  2389.     fi
  2390.  
  2391.  
  2392.     return 0
  2393. } &&
  2394. complete -F _apt_cache $filenames apt-cache
  2395.  
  2396.  
  2397. # Debian aptitude(1) completion
  2398. #
  2399. have aptitude && {
  2400. have grep-status && {
  2401. _comp_dpkg_hold_packages()
  2402. {
  2403.     grep-status -P -e "^$1" -a -FStatus 'hold' -n -s Package
  2404. }
  2405. } || {
  2406. _comp_dpkg_hold_packages()
  2407. {
  2408.     grep -B 2 'hold' /var/lib/dpkg/status | grep "Package: $1" \
  2409.         | cut -d\  -f2
  2410. }
  2411. }
  2412.  
  2413. _aptitude()
  2414. {
  2415.     local cur dashoptions prev special i
  2416.  
  2417.     COMPREPLY=()
  2418.     cur=`_get_cword`
  2419.     prev=${COMP_WORDS[COMP_CWORD-1]}
  2420.  
  2421.  
  2422.     dashoptions='-S -u -i -h --help --version -s --simulate -d \
  2423.              --download-only -P --prompt -y --assume-yes -F \
  2424.              --display-format -O --sort -w --width -f -r -g \
  2425.              --with-recommends --with-suggests -R -G \
  2426.              --without-recommends --without-suggests -t \
  2427.              --target-release -V --show-versions -D --show-deps\
  2428.              -Z -v --verbose --purge-unused --schedule-only'
  2429.  
  2430.     for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
  2431.         if [[ ${COMP_WORDS[i]} == @(install|reinstall|hold|unhold|markauto|unmarkauto|dist-upgrade|full-upgrade|download|show|forbid-version|purge|remove|changelog|why|why-not|keep|keep-all|build-dep) ]]; then
  2432.         special=${COMP_WORDS[i]}
  2433.         fi
  2434.         #exclude some mutually exclusive options
  2435.         [[ ${COMP_WORDS[i]} == '-u' ]] && dashoptions=${dashoptions/-i}
  2436.         [[ ${COMP_WORDS[i]} == '-i' ]] && dashoptions=${dashoptions/-u}
  2437.     done
  2438.  
  2439.     if [[ -n "$special" ]]; then
  2440.        case $special in
  2441.            @(install|hold|markauto|unmarkauto|dist-upgrade|full-upgrade|download|show|changelog|why|why-not|build-dep))
  2442.            COMPREPLY=( $( apt-cache pkgnames $cur 2> /dev/null ) )
  2443.            return 0
  2444.            ;;
  2445.            @(purge|remove|reinstall|forbid-version))
  2446.              COMPREPLY=( $( _comp_dpkg_installed_packages $cur ) )
  2447.            return 0
  2448.            ;;
  2449.            unhold)
  2450.              COMPREPLY=( $( _comp_dpkg_hold_packages $cur ) )
  2451.            return 0
  2452.            ;;
  2453.  
  2454.        esac
  2455.     fi
  2456.  
  2457.     case $prev in
  2458.         # don't complete anything if these options are found
  2459.         @(autoclean|clean|forget-new|search|upgrade|safe-upgrade|update|keep-all))
  2460.         return 0
  2461.         ;;
  2462.  
  2463.         -S)
  2464.         _filedir
  2465.         return 0
  2466.         ;;
  2467.  
  2468.         -@(t|-target-release|-default-release))
  2469.         COMPREPLY=( $( apt-cache policy | \
  2470.             grep "release.o=Debian,a=$cur" | \
  2471.             sed -e "s/.*a=\(\w*\).*/\1/" | uniq 2> /dev/null ) )
  2472.         return 0
  2473.         ;;
  2474.  
  2475.     esac
  2476.  
  2477.     if [[ "$cur" == -* ]]; then
  2478.         COMPREPLY=( $( compgen -W "$dashoptions" -- $cur ) )
  2479.     else
  2480.         COMPREPLY=( $( compgen -W 'update upgrade safe-upgrade forget-new clean \
  2481.                        autoclean install reinstall remove \
  2482.                        hold unhold purge markauto unmarkauto why why-not \
  2483.                        dist-upgrade full-upgrade download search show \
  2484.                        forbid-version changelog keep-all build-dep' -- $cur ) )
  2485.     fi
  2486.  
  2487.  
  2488.     return 0
  2489. }
  2490. complete -F _aptitude $default aptitude
  2491. }
  2492.  
  2493. # Debian apt-build(1) completion.
  2494. #
  2495. have apt-build &&
  2496. _apt_build()
  2497. {
  2498.     local cur prev special i
  2499.  
  2500.     COMPREPLY=()
  2501.     cur=`_get_cword`
  2502.     prev=${COMP_WORDS[COMP_CWORD-1]}
  2503.  
  2504.     for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
  2505.         if [[ ${COMP_WORDS[i]} == @(install|remove|source|info|clean) ]]; then
  2506.             special=${COMP_WORDS[i]}
  2507.         fi
  2508.     done
  2509.  
  2510.     if [ -n "$special" ]; then
  2511.         case $special in
  2512.         @(install|source|info))
  2513.             COMPREPLY=( $( apt-cache pkgnames $cur 2> /dev/null ) )
  2514.             return 0
  2515.             ;;
  2516.         remove)
  2517.             COMPREPLY=( $( _comp_dpkg_installed_packages \
  2518.                     $cur ) )
  2519.             return 0
  2520.             ;;
  2521.         *)
  2522.             return 0
  2523.             ;;
  2524.         esac
  2525.     fi
  2526.  
  2527.     case "$prev" in
  2528.  
  2529.          --@(patch|build-dir|repository-dir))
  2530.            _filedir
  2531.            return 0
  2532.            ;;
  2533.  
  2534.          -@(h|-help))
  2535.            return 0
  2536.            ;;
  2537.  
  2538.     esac
  2539.  
  2540.     if [[ "$cur" == -* ]]; then
  2541.         COMPREPLY=( $( compgen -W '--help --show-upgraded -u --build-dir \
  2542.                   --repository-dir --build-only \
  2543.                   --build-command --reinstall --rebuild \
  2544.                   --remove-builddep --no-wrapper --purge \
  2545.                   --patch --patch-strip -p --yes -y \
  2546.                   --version -v --no-source' -- $cur ) )
  2547.  
  2548.     else
  2549.         COMPREPLY=( $( compgen -W 'update upgrade install remove \
  2550.                   source dist-upgrade world clean info \
  2551.                   clean-build update-repository ' -- $cur ) )
  2552.     fi
  2553.  
  2554.  
  2555.     return 0
  2556. } &&
  2557. complete -F _apt_build $filenames apt-build
  2558.  
  2559. # chsh(1) completion
  2560. #
  2561. _chsh()
  2562. {
  2563.     local cur prev
  2564.  
  2565.     COMPREPLY=()
  2566.     cur=`_get_cword`
  2567.     prev=${COMP_WORDS[COMP_CWORD-1]}
  2568.  
  2569.     if [ "$prev" = "-s" ]; then
  2570.       if [ -f /etc/debian_version ]; then
  2571.         COMPREPLY=( $( </etc/shells ) )
  2572.       else
  2573.         COMPREPLY=( $( chsh -l | grep "^$cur" ) )
  2574.       fi
  2575.     else
  2576.       COMPREPLY=( $( compgen -u -- $cur ) )
  2577.     fi
  2578.  
  2579.     return 0
  2580. }
  2581. complete -F _chsh chsh
  2582.  
  2583. # chkconfig(8) completion
  2584. #
  2585. have chkconfig &&
  2586. _chkconfig()
  2587. {
  2588.     local cur prev
  2589.  
  2590.     COMPREPLY=()
  2591.     cur=`_get_cword`
  2592.     prev=${COMP_WORDS[COMP_CWORD-1]}
  2593.  
  2594.     case "$prev" in
  2595.     @([1-6]|--@(list|add|del)))
  2596.         _services
  2597.         return 0
  2598.         ;;
  2599.     --level)
  2600.         COMPREPLY=( $( compgen -W '1 2 3 4 5 6' -- $cur ) )
  2601.         return 0
  2602.         ;;
  2603.     esac
  2604.  
  2605.     if [[ "$cur" == -* ]]; then
  2606.         COMPREPLY=( $( compgen -W '--list --add --del --level' -- $cur ) )
  2607.     else
  2608.         if [ $COMP_CWORD -eq 2 -o $COMP_CWORD -eq 4 ]; then
  2609.             COMPREPLY=( $( compgen -W 'on off reset' -- $cur ) )
  2610.         else
  2611.             _services
  2612.         fi
  2613.     fi
  2614. } &&
  2615. complete -F _chkconfig chkconfig
  2616.  
  2617. # This function provides simple user@host completion
  2618. #
  2619. _user_at_host() {
  2620.     local cur
  2621.  
  2622.     COMPREPLY=()
  2623.     cur=`_get_cword`
  2624.  
  2625.     if [[ $cur == *@* ]]; then
  2626.         _known_hosts
  2627.     else
  2628.         COMPREPLY=( $( compgen -u -- "$cur" ) )
  2629.     fi
  2630.  
  2631.     return 0
  2632. }
  2633. shopt -u hostcomplete && complete -F _user_at_host $nospace talk ytalk finger
  2634.  
  2635. # This function performs host completion based on ssh's known_hosts files,
  2636. # defaulting to standard host completion if they don't exist.
  2637. #
  2638. # Arguments:  -a             Use aliases
  2639. #             -c             Use `:' suffix
  2640. #             -F configfile  Use `configfile' for configuration settings
  2641. _known_hosts()
  2642. {
  2643.     local configfile
  2644.     local cur curd ocur user suffix aliases global_kh user_kh hosts i host
  2645.     local -a kh khd config
  2646.  
  2647.     COMPREPLY=()
  2648.     cur=`_get_cword`
  2649.     ocur=$cur
  2650.  
  2651.     local OPTIND=1
  2652.     while getopts "acF:" flag "$@"; do
  2653.         case $flag in
  2654.             a) aliases='yes' ;;
  2655.             c) suffix=':' ;;
  2656.             F) configfile="$OPTARG" ;;
  2657.         esac
  2658.     done
  2659.     
  2660.     [[ $cur == *@* ]] && user=${cur%@*}@ && cur=${cur#*@}
  2661.     kh=()
  2662.  
  2663.     # ssh config files
  2664.     if [ -n "$configfile" ]; then
  2665.         [ -r "$configfile" ] &&
  2666.           config=( "${config[@]}" "$configfile" )
  2667.     else
  2668.         [ -r /etc/ssh/ssh_config ] &&
  2669.           config=( "${config[@]}" "/etc/ssh/ssh_config" )
  2670.         [ -r "${HOME}/.ssh/config" ] &&
  2671.           config=( "${config[@]}" "${HOME}/.ssh/config" )
  2672.         [ -r "${HOME}/.ssh2/config" ] &&
  2673.           config=( "${config[@]}" "${HOME}/.ssh2/config" )
  2674.     fi
  2675.  
  2676.     if [ ${#config[@]} -gt 0 ]; then
  2677.         # expand path (if present) to global known hosts file
  2678.         global_kh=$( eval echo "$( sed -ne 's/^[ \t]*[Gg][Ll][Oo][Bb][Aa][Ll][Kk][Nn][Oo][Ww][Nn][Hh][Oo][Ss][Tt][Ss][Ff][Ii][Ll][Ee]['"$'\t '"']*\(.*\)$/\1/p' "${config[@]}" )" )
  2679.         # expand path (if present) to user known hosts file
  2680.         user_kh=$( eval echo "$( sed -ne 's/^[ \t]*[Uu][Ss][Ee][Rr][Kk][Nn][Oo][Ww][Nn][Hh][Oo][Ss][Tt][Ss][Ff][Ii][Ll][Ee]['"$'\t '"']*\(.*\)$/\1/p' "${config[@]}" )" )
  2681.     fi
  2682.  
  2683.     # Global known_hosts files
  2684.     [ -r "$global_kh" ] &&
  2685.         kh=( "${kh[@]}" "$global_kh" )
  2686.     if [ -z "$configfile" ]; then
  2687.         [ -r /etc/ssh/ssh_known_hosts ] &&
  2688.           kh=( "${kh[@]}" /etc/ssh/ssh_known_hosts )
  2689.         [ -r /etc/ssh/ssh_known_hosts2 ] &&
  2690.           kh=( "${kh[@]}" /etc/ssh/ssh_known_hosts2 )
  2691.         [ -r /etc/known_hosts ] &&
  2692.           kh=( "${kh[@]}" /etc/known_hosts )
  2693.         [ -r /etc/known_hosts2 ] &&
  2694.           kh=( "${kh[@]}" /etc/known_hosts2 )
  2695.         [ -d /etc/ssh2/knownhosts ] &&
  2696.           khd=( "${khd[@]}" /etc/ssh2/knownhosts/*pub )
  2697.     fi
  2698.  
  2699.     # User known_hosts files
  2700.     [ -r "$user_kh" ] &&
  2701.         kh=( "${kh[@]}" "$user_kh" )
  2702.     if [ -z "$configfile" ]; then
  2703.         [ -r ~/.ssh/known_hosts ] &&
  2704.           kh=( "${kh[@]}" ~/.ssh/known_hosts )
  2705.         [ -r ~/.ssh/known_hosts2 ] &&
  2706.           kh=( "${kh[@]}" ~/.ssh/known_hosts2 )
  2707.         [ -d ~/.ssh2/hostkeys ] &&
  2708.           khd=( "${khd[@]}" ~/.ssh2/hostkeys/*pub )
  2709.     fi
  2710.  
  2711.     # If we have known_hosts files to use
  2712.     if [ ${#kh[@]} -gt 0 -o ${#khd[@]} -gt 0 -o -n "$configfile" ]; then
  2713.         # Escape slashes and dots in paths for awk
  2714.         cur=${cur//\//\\\/}
  2715.         cur=${cur//\./\\\.}
  2716.         curd=$cur
  2717.  
  2718.         if [[ "$cur" == [0-9]*.* ]]; then
  2719.         # Digits followed by a dot - just search for that
  2720.         cur="^$cur.*"
  2721.         elif [[ "$cur" == [0-9]* ]]; then
  2722.         # Digits followed by no dot - search for digits followed
  2723.         # by a dot
  2724.         cur="^$cur.*\."
  2725.         elif [ -z "$cur" ]; then
  2726.         # A blank - search for a dot or an alpha character
  2727.         cur="[a-z.]"
  2728.         else
  2729.         cur="^$cur"
  2730.         fi
  2731.  
  2732.         if [ ${#kh[@]} -gt 0 ]; then
  2733.  
  2734.         # FS needs to look for a comma separated list
  2735.         COMPREPLY=( $( awk 'BEGIN {FS=","}
  2736.                 /^\s*[^|\#]/ {for (i=1; i<=2; ++i) { \
  2737.                        gsub(" .*$", "", $i); \
  2738.                        if ($i ~ /'$cur'/) {print $i} \
  2739.                 }}' "${kh[@]}" 2>/dev/null ) )
  2740.         fi
  2741.         if [ ${#khd[@]} -gt 0 ]; then
  2742.         # Needs to look for files called
  2743.         # .../.ssh2/key_22_<hostname>.pub
  2744.         # dont fork any processes, because in a cluster environment,
  2745.         # there can be hundreds of hostkeys
  2746.         for i in "${khd[@]}" ; do
  2747.             if [[ "$i" == *key_22_$curd*.pub ]] && [ -r "$i" ] ; then
  2748.             host=${i/#*key_22_/}
  2749.             host=${host/%.pub/}
  2750.             COMPREPLY=( "${COMPREPLY[@]}" $host )
  2751.             fi
  2752.         done
  2753.         fi
  2754.         # append any available aliases from config files
  2755.         if [ ${#config[@]} -gt 0 ] && [ -n "$aliases" ]; then
  2756.         local host_aliases=$( sed -ne 's/^[ \t]*[Hh][Oo][Ss][Tt]\([Nn][Aa][Mm][Ee]\)\?['"$'\t '"']\+\([^#*?]*\)\(#.*\)\?$/\2/p' "${config[@]}" )
  2757.         hosts=$( compgen -W "$host_aliases" -- $ocur )
  2758.         COMPREPLY=( "${COMPREPLY[@]}" $hosts )
  2759.         fi
  2760.  
  2761.         # Now add results of normal hostname completion
  2762.         COMPREPLY=( "${COMPREPLY[@]}" $( compgen -A hostname -- $ocur ) )
  2763.  
  2764.         # apply suffix
  2765.         for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
  2766.         COMPREPLY[i]=$user${COMPREPLY[i]}$suffix
  2767.         done
  2768.     elif [ -z "$configfile" ]; then
  2769.         # Just do normal hostname completion
  2770.         COMPREPLY=( $( compgen -A hostname -S "$suffix" -- $cur ) )
  2771.     fi
  2772.  
  2773.     return 0
  2774. }
  2775. complete -F _known_hosts traceroute traceroute6 tracepath tracepath6 \
  2776.     ping ping6 fping fping6 telnet host nslookup rsh rlogin ftp dig ssh-installkeys mtr
  2777.  
  2778. # rsync(1) completion
  2779. #
  2780. have rsync &&
  2781. _rsync()
  2782. {
  2783.     local cur prev shell i userhost path
  2784.  
  2785.     COMPREPLY=()
  2786.     cur=`_get_cword`
  2787.     prev=${COMP_WORDS[COMP_CWORD-1]}
  2788.  
  2789.     _expand || return 0
  2790.  
  2791.     case "$prev" in
  2792.     --@(config|password-file|include-from|exclude-from))
  2793.         _filedir
  2794.         return 0
  2795.         ;;
  2796.     -@(T|-temp-dir|-compare-dest))
  2797.         _filedir -d
  2798.         return 0
  2799.         ;;
  2800.     -@(e|-rsh))
  2801.         COMPREPLY=( $( compgen -W 'rsh ssh' -- $cur ) )
  2802.         return 0
  2803.         ;;
  2804.     esac
  2805.  
  2806.     case "$cur" in
  2807.     -*)
  2808.         COMPREPLY=( $( compgen -W '-v -q  -c -a -r -R -b -u -l -L -H \
  2809.                 -p -o -g -D -t -S -n -W -x -B -e -C -I -T -P \
  2810.                 -z -h -4 -6 --verbose --quiet --checksum \
  2811.                 --archive --recursive --relative --backup \
  2812.                 --backup-dir --suffix= --update --links \
  2813.                 --copy-links --copy-unsafe-links --safe-links \
  2814.                 --hard-links --perms --owner --group --devices\
  2815.                 --times --sparse --dry-run --whole-file \
  2816.                 --no-whole-file --one-file-system \
  2817.                 --block-size= --rsh= --rsync-path= \
  2818.                 --cvs-exclude --existing --ignore-existing \
  2819.                 --delete --delete-excluded --delete-after \
  2820.                 --ignore-errors --max-delete= --partial \
  2821.                 --force --numeric-ids --timeout= \
  2822.                 --ignore-times --size-only --modify-window= \
  2823.                 --temp-dir= --compare-dest= --compress \
  2824.                 --exclude= --exclude-from= --include= \
  2825.                 --include-from= --version --daemon --no-detach\
  2826.                 --address= --config= --port= --blocking-io \
  2827.                 --no-blocking-io --stats --progress \
  2828.                 --log-format= --password-file= --bwlimit= \
  2829.                 --write-batch= --read-batch= --help' -- $cur ))
  2830.         ;;
  2831.     *:*)
  2832.         # find which remote shell is used
  2833.         shell=ssh
  2834.         for (( i=1; i < COMP_CWORD; i++ )); do
  2835.             if [[ "${COMP_WORDS[i]}" == -@(e|-rsh) ]]; then
  2836.                 shell=${COMP_WORDS[i+1]}
  2837.                 break
  2838.             fi
  2839.         done
  2840.         if [[ "$shell" == ssh ]]; then
  2841.             # remove backslash escape from :
  2842.             cur=${cur/\\:/:}
  2843.             userhost=${cur%%?(\\):*}
  2844.             path=${cur#*:}
  2845.             # unescape spaces
  2846.             path=${path//\\\\\\\\ / }
  2847.             if [ -z "$path" ]; then
  2848.                 # default to home dir of specified
  2849.                 # user on remote host
  2850.                 path=$(ssh -o 'Batchmode yes' \
  2851.                     $userhost pwd 2>/dev/null)
  2852.             fi
  2853.             # escape spaces; remove executables, aliases, pipes
  2854.             # and sockets; add space at end of file names
  2855.             COMPREPLY=( $( ssh -o 'Batchmode yes' $userhost \
  2856.                 command ls -aF1d "$path*" 2>/dev/null | \
  2857.                 sed -e 's/ /\\\\\\\ /g' -e 's/[*@|=]$//g' \
  2858.                 -e 's/[^\/]$/& /g' ) )
  2859.         fi
  2860.         ;;
  2861.     *)
  2862.         _known_hosts -c -a
  2863.         _filedir
  2864.         ;;
  2865.     esac
  2866.  
  2867.     return 0
  2868. } &&
  2869. complete -F _rsync $nospace $filenames rsync
  2870.  
  2871. # Linux route(8) completion
  2872. #
  2873. [ $UNAME = Linux ] &&
  2874. _route()
  2875. {
  2876.     local cur prev
  2877.  
  2878.     COMPREPLY=()
  2879.     cur=`_get_cword`
  2880.     prev=${COMP_WORDS[COMP_CWORD-1]}
  2881.  
  2882.     if [ "$prev" = dev ]; then
  2883.         COMPREPLY=( $( ifconfig -a | sed -ne 's|^\('$cur'[^ ]*\).*$|\1|p' ))
  2884.         return 0
  2885.     fi
  2886.  
  2887.     COMPREPLY=( $( compgen -W 'add del -host -net netmask metric mss \
  2888.                    window irtt reject mod dyn reinstate dev \
  2889.                    default gw' -- $cur ) )
  2890.  
  2891.     COMPREPLY=( $( echo " ${COMP_WORDS[@]}" | \
  2892.                (while read -d ' ' i; do
  2893.                [ "$i" == "" ] && continue
  2894.                # flatten array with spaces on either side,
  2895.                # otherwise we cannot grep on word
  2896.                # boundaries of first and last word
  2897.                COMPREPLY=" ${COMPREPLY[@]} "
  2898.                # remove word from list of completions
  2899.                COMPREPLY=( ${COMPREPLY/ $i / } )
  2900.             done
  2901.                echo "${COMPREPLY[@]}")
  2902.           ) )
  2903.     return 0
  2904. }
  2905. [ $UNAME = Linux ] && complete -F _route route
  2906.  
  2907. # GNU make(1) completion
  2908. #
  2909. have make || have gmake || have gnumake || have pmake &&
  2910. _make()
  2911. {
  2912.     local file makef makef_dir="." makef_inc cur prev i
  2913.  
  2914.     COMPREPLY=()
  2915.     cur=`_get_cword`
  2916.     prev=${COMP_WORDS[COMP_CWORD-1]}
  2917.  
  2918.     # --name value style option
  2919.     case $prev in
  2920.         -@(f|o|W))
  2921.             _filedir
  2922.             return 0
  2923.             ;;
  2924.         -@(I|C))
  2925.             _filedir -d
  2926.             return 0
  2927.             ;;
  2928.     esac
  2929.  
  2930.     # --name=value style option
  2931.     if [[ "$cur" == *=* ]]; then
  2932.         prev=${cur/=*/}
  2933.         cur=${cur/*=/}
  2934.         case "$prev" in
  2935.             --@(file|makefile))
  2936.                 _filedir
  2937.                 return 0
  2938.                 ;;
  2939.             --@(directory|include-dir))
  2940.                 _filedir -d
  2941.                 return 0
  2942.                 ;;
  2943.         esac
  2944.     fi
  2945.  
  2946.     if [[ "$cur" == -* ]]; then
  2947.         COMPREPLY=( $( compgen -W '-b -m -B -C -d -e -f -h -i -I\
  2948.             -j -l -k -n -o -p -q -r -R - s -S -t -v -w -W \
  2949.             --always-make --directory= --debug \
  2950.             --environment-overrides --file= --makefile= --help \
  2951.             --ignore-errors --include-dir= --jobs --load-average \
  2952.             --max-load --keep-going --just-print --dry-run \
  2953.             --recon --old-file= --assume-old= --print-data-base \
  2954.             --question --no-builtin-rules --no-builtin-variables \
  2955.             --silent --quiet --no-keep-goind --stop --touch \
  2956.             --version --print-directory --no-print-directory \
  2957.             --what-if= --new-file= --assume-new= \
  2958.             --warn-undefined-variables' -- $cur ) )
  2959.     else
  2960.         # before we check for makefiles, see if a path was specified
  2961.         # with -C
  2962.         for (( i=0; i < ${#COMP_WORDS[@]}; i++ )); do
  2963.             if [[ ${COMP_WORDS[i]} == -C ]]; then
  2964.                 # eval for tilde expansion
  2965.                 eval makef_dir=${COMP_WORDS[i+1]}
  2966.                 break
  2967.             fi
  2968.         done
  2969.  
  2970.         # before we scan for targets, see if a Makefile name was
  2971.         # specified with -f
  2972.         for (( i=0; i < ${#COMP_WORDS[@]}; i++ )); do
  2973.             if [[ ${COMP_WORDS[i]} == -f ]]; then
  2974.                 # eval for tilde expansion
  2975.                 eval makef=${COMP_WORDS[i+1]}
  2976.                 break
  2977.             fi
  2978.         done
  2979.  
  2980.         [ -n "$makef" ] && makef="-f ${makef}"
  2981.         [ -n "$makef_dir" ] && makef_dir="-C ${makef_dir}"
  2982.         
  2983.         COMPREPLY=( $( make -qp $makef $makef_dir 2>/dev/null | \
  2984.                     awk -F':' '/^[a-zA-Z0-9][^$#\/\t=]*:([^=]|$)/ \
  2985.                     {split($1,A,/ /);for(i in A)print A[i]}' | \
  2986.                     command grep "^$cur" ))
  2987.  
  2988.     fi
  2989. } &&
  2990. complete -f -F _make $filenames make gmake gnumake pmake
  2991.  
  2992. # GNU tar(1) completion
  2993. #
  2994. _tar()
  2995. {
  2996.     local cur ext regex tar untar
  2997.  
  2998.     COMPREPLY=()
  2999.     cur=`_get_cword`
  3000.  
  3001.     if [ $COMP_CWORD -eq 1 ]; then
  3002.         COMPREPLY=( $( compgen -W 'c t x u r d A' -- $cur ) )
  3003.         return 0
  3004.     fi
  3005.  
  3006.     case "${COMP_WORDS[1]}" in
  3007.     ?(-)[cr]*f)
  3008.         _filedir
  3009.         return 0
  3010.         ;;
  3011.     +([^IZzJjy])f)
  3012.         ext='t@(ar?(.@(Z|gz|bz?(2)|lz?(ma)))|gz|bz?(2)|lz?(ma))'
  3013.         regex='t\(ar\(\.\(Z\|gz\|bz2\?\|lzma\)\)\?\|gz\|bz2\?\|lzma\)'
  3014.         ;;
  3015.     *[Zz]*f)
  3016.         ext='t?(ar.)@(gz|Z)'
  3017.         regex='t\(ar\.\)\?\(gz\|Z\)'
  3018.         ;;
  3019.     *[Ijy]*f)
  3020.         ext='t?(ar.)bz?(2)'
  3021.         regex='t\(ar\.\)\?bz2\?'
  3022.         ;;
  3023.     *[J]*f)
  3024.         ext='t?(ar.)lz?(ma)'
  3025.         regex='t\(ar\.\)\?lzma\?'
  3026.         ;;
  3027.     *)
  3028.         _filedir
  3029.         return 0
  3030.         ;;
  3031.  
  3032.     esac
  3033.  
  3034.     if [[ "$COMP_LINE" == *$ext' ' ]]; then
  3035.         # complete on files in tar file
  3036.         #
  3037.         # get name of tar file from command line
  3038.         tar=$( echo "$COMP_LINE" | \
  3039.             sed -e 's/^.* \([^ ]*'$regex'\) .*$/\1/' )
  3040.         # devise how to untar and list it
  3041.         untar=t${COMP_WORDS[1]//[^Izjyf]/}
  3042.  
  3043.         COMPREPLY=( $( compgen -W "$( echo $( tar $untar $tar \
  3044.                 2>/dev/null ) )" -- "$cur" ) )
  3045.         return 0
  3046.     fi
  3047.  
  3048.     # file completion on relevant files
  3049.     _filedir "$ext"
  3050.  
  3051.     return 0
  3052. }
  3053. [ -n "${COMP_TAR_INTERNAL_PATHS:-}" ] && complete -F _tar $dirnames tar ||
  3054.     complete -F _tar $filenames tar
  3055.  
  3056. # jar(1) completion
  3057. #
  3058. have jar &&
  3059. _jar()
  3060. {
  3061.     local cur
  3062.  
  3063.     COMPREPLY=()
  3064.     cur=`_get_cword`
  3065.  
  3066.     if [ $COMP_CWORD = 1 ]; then
  3067.         COMPREPLY=( $( compgen -W 'c t x u' -- $cur ) )
  3068.         return 0
  3069.     fi
  3070.  
  3071.     case "${COMP_WORDS[1]}" in
  3072.         *c*f)
  3073.             _filedir
  3074.             ;;
  3075.         *f)
  3076.             _filedir '?([ejw]ar|zip|[EJW]AR|ZIP)'
  3077.             ;;
  3078.         *)
  3079.             _filedir
  3080.             ;;
  3081.     esac
  3082. } &&
  3083. complete -F _jar $filenames jar
  3084.  
  3085. # Linux iptables(8) completion
  3086. #
  3087. have iptables &&
  3088. _iptables()
  3089. {
  3090.     local cur prev table chain
  3091.  
  3092.     COMPREPLY=()
  3093.     cur=`_get_cword`
  3094.     prev=${COMP_WORDS[COMP_CWORD-1]}
  3095.     chain='s/^Chain \([^ ]\+\).*$/\1/p'
  3096.  
  3097.     if [[ $COMP_LINE == *-t\ *filter* ]]; then
  3098.         table="-t filter"
  3099.     elif [[ $COMP_LINE == *-t\ *nat* ]]; then
  3100.         table="-t nat"
  3101.     elif [[ $COMP_LINE == *-t\ *mangle* ]]; then
  3102.         table="-t mangle"
  3103.     fi
  3104.  
  3105.     case "$prev" in
  3106.     -*[AIDRPFXLZ])
  3107.         COMPREPLY=( $( compgen -W '`iptables $table -nL | \
  3108.                 sed -ne "s/^Chain \([^ ]\+\).*$/\1/p"`' -- $cur ) )
  3109.         ;;
  3110.     -*t)
  3111.         COMPREPLY=( $( compgen -W 'nat filter mangle' -- $cur ) )
  3112.         ;;
  3113.     -j)
  3114.         if [ "$table" = "-t filter" -o "$table" = "" ]; then
  3115.             COMPREPLY=( $( compgen -W 'ACCEPT DROP LOG ULOG REJECT \
  3116.             `iptables $table -nL | sed -ne "$chain" \
  3117.             -e "s/INPUT|OUTPUT|FORWARD|PREROUTING|POSTROUTING//"`' -- \
  3118.             $cur ) )
  3119.         elif [ "$table" = "-t nat" ]; then
  3120.             COMPREPLY=( $( compgen -W 'ACCEPT DROP LOG ULOG REJECT \
  3121.             MIRROR SNAT DNAT MASQUERADE `iptables $table -nL | \
  3122.             sed -ne "$chain" -e "s/OUTPUT|PREROUTING|POSTROUTING//"`' \
  3123.             -- $cur ) )
  3124.         elif [ "$table" = "-t mangle" ]; then
  3125.             COMPREPLY=( $( compgen -W 'ACCEPT DROP LOG ULOG REJECT \
  3126.             MARK TOS `iptables $table -nL | sed -ne "$chain" \
  3127.             -e "s/INPUT|OUTPUT|FORWARD|PREROUTING|POSTROUTING//"`' -- \
  3128.             $cur ) )
  3129.         fi
  3130.         ;;
  3131.     *)
  3132.         if [[ "$cur" == -* ]]; then
  3133.             COMPREPLY=( $( compgen -W '-i -o -s -d -p -f -m --append \
  3134.             --delete --insert --replace --list --flush --zero --new \
  3135.             --delete-chain --policy --rename-chain --proto --source \
  3136.             --destination --in-interface --jump --match --numeric \
  3137.             --out-interface --table --verbose --line-numbers --exact \
  3138.             --fragment --modprobe= --set-counters --version' -- "$cur") )
  3139.         fi
  3140.         ;;
  3141.     esac
  3142.  
  3143. } &&
  3144. complete -F _iptables iptables
  3145.  
  3146. # tcpdump(8) completion
  3147. #
  3148. have tcpdump &&
  3149. _tcpdump()
  3150. {
  3151.     local cur
  3152.  
  3153.     COMPREPLY=()
  3154.     cur=`_get_cword`
  3155.     prev=${COMP_WORDS[COMP_CWORD-1]}
  3156.  
  3157.     case "$prev" in
  3158.         -@(r|w|F))
  3159.             _filedir
  3160.             return 0
  3161.             ;;
  3162.         -i)
  3163.             _available_interfaces -a
  3164.             return 0
  3165.             ;;
  3166.     esac
  3167.  
  3168.  
  3169.     if [[ "$cur" == -* ]]; then
  3170.         COMPREPLY=( $( compgen -W '-a -d -e -f -l -n -N -O -p \
  3171.             -q -R -S -t -u -v -x -C -F -i -m -r -s -T -w \
  3172.             -E' -- $cur ) )
  3173.     fi
  3174.  
  3175. } &&
  3176. complete -F _tcpdump tcpdump
  3177.  
  3178. # autorpm(8) completion
  3179. #
  3180. have autorpm &&
  3181. _autorpm()
  3182. {
  3183.     local cur
  3184.  
  3185.     COMPREPLY=()
  3186.     cur=`_get_cword`
  3187.  
  3188.     COMPREPLY=( $( compgen -W '--notty --debug --help --version \
  3189.                    auto add fullinfo info help install list \
  3190.                    remove set' -- $cur ) )
  3191.  
  3192. } &&
  3193. complete -F _autorpm autorpm
  3194.  
  3195. # This meta-cd function observes the CDPATH variable, so that cd additionally
  3196. # completes on directories under those specified in CDPATH.
  3197. #
  3198. _cd()
  3199. {
  3200.     local IFS=$'\t\n' cur=`_get_cword` i j k
  3201.  
  3202.     # try to allow variable completion
  3203.     if [[ "$cur" == ?(\\)\$* ]]; then
  3204.         COMPREPLY=( $( compgen -v -P '$' -- "${cur#?(\\)$}" ) )
  3205.         return 0
  3206.     fi
  3207.  
  3208.     # Enable -o filenames option, see Debian bug #272660
  3209.     compgen -f /non-existing-dir/ >/dev/null
  3210.  
  3211.     # Use standard dir completion if no CDPATH or parameter starts with /,
  3212.     # ./ or ../
  3213.     if [ -z "${CDPATH:-}" ] || [[ "$cur" == ?(.)?(.)/* ]]; then
  3214.         _filedir -d
  3215.         return 0
  3216.     fi
  3217.  
  3218.     local -r mark_dirs=$(_rl_enabled mark-directories && echo y)
  3219.     local -r mark_symdirs=$(_rl_enabled mark-symlinked-directories && echo y)
  3220.  
  3221.     # we have a CDPATH, so loop on its contents
  3222.     for i in ${CDPATH//:/$'\t'}; do
  3223.         # create an array of matched subdirs
  3224.         k="${#COMPREPLY[@]}"
  3225.         for j in $( compgen -d $i/$cur ); do
  3226.             if [[ ( $mark_symdirs && -h $j || $mark_dirs && ! -h $j ) && ! -d ${j#$i/} ]]; then
  3227.                 j="${j}/"
  3228.             fi
  3229.             COMPREPLY[k++]=${j#$i/}
  3230.         done
  3231.     done
  3232.  
  3233.     _filedir -d
  3234.  
  3235.     if [[ ${#COMPREPLY[@]} -eq 1 ]]; then
  3236.         i=${COMPREPLY[0]}
  3237.         if [ "$i" == "$cur" ] && [[ $i != "*/" ]]; then
  3238.         COMPREPLY[0]="${i}/"
  3239.         fi
  3240.     fi
  3241.  
  3242.     return 0
  3243. }
  3244. if shopt -q cdable_vars; then
  3245.     complete -v -F _cd $nospace cd
  3246. else
  3247.     complete -F _cd $nospace cd
  3248. fi
  3249.  
  3250. # a wrapper method for the next one, when the offset is unknown
  3251. _command()
  3252. {
  3253.     local offset i
  3254.  
  3255.     # find actual offset, as position of the first non-option
  3256.     offset=1
  3257.     for (( i=1; i <= COMP_CWORD; i++ )); do
  3258.         if [[ "${COMP_WORDS[i]}" != -* ]]; then
  3259.             offset=$i
  3260.             break
  3261.         fi
  3262.     done
  3263.     _command_offset $offset
  3264. }
  3265.  
  3266. # A meta-command completion function for commands like sudo(8), which need to
  3267. # first complete on a command, then complete according to that command's own
  3268. # completion definition - currently not quite foolproof (e.g. mount and umount
  3269. # don't work properly), but still quite useful.
  3270. #
  3271. _command_offset()
  3272. {
  3273.     local cur func cline cspec noglob cmd i char_offset word_offset \
  3274.           _COMMAND_FUNC _COMMAND_FUNC_ARGS
  3275.  
  3276.     word_offset=$1
  3277.  
  3278.     # rewrite current completion context before invoking
  3279.     # actual command completion
  3280.  
  3281.     # find new first word position, then
  3282.     # rewrite COMP_LINE and adjust COMP_POINT
  3283.     local first_word=${COMP_WORDS[$word_offset]}
  3284.     for (( i=0; i <= ${#COMP_LINE}; i++ )); do
  3285.         if [[ "${COMP_LINE:$i:${#first_word}}" == "$first_word" ]]; then
  3286.             char_offset=$i
  3287.             break
  3288.         fi
  3289.     done
  3290.     COMP_LINE=${COMP_LINE:$char_offset}
  3291.     COMP_POINT=$(( COMP_POINT - $char_offset ))
  3292.  
  3293.     # shift COMP_WORDS elements and adjust COMP_CWORD
  3294.     for (( i=0; i <= COMP_CWORD - $word_offset; i++ )); do
  3295.         COMP_WORDS[i]=${COMP_WORDS[i+$word_offset]}
  3296.     done
  3297.     for (( i; i <= COMP_CWORD; i++ )); do
  3298.         unset COMP_WORDS[i];
  3299.     done
  3300.     COMP_CWORD=$(( $COMP_CWORD - $word_offset ))
  3301.  
  3302.     COMPREPLY=()
  3303.     cur=`_get_cword`
  3304.  
  3305.     if [[ $COMP_CWORD -eq 0 ]]; then
  3306.         COMPREPLY=( $( compgen -c -- $cur ) )
  3307.     else
  3308.         cmd=${COMP_WORDS[0]}
  3309.         if complete -p $cmd &>/dev/null; then
  3310.         cspec=$( complete -p $cmd )
  3311.         if [ "${cspec#* -F }" != "$cspec" ]; then
  3312.             # complete -F <function>
  3313.  
  3314.             # get function name
  3315.             func=${cspec#*-F }
  3316.             func=${func%% *}
  3317.             
  3318.             if [[ ${#COMP_WORDS[@]} -ge 2 ]]; then
  3319.                 $func $cmd "${COMP_WORDS[${#COMP_WORDS[@]}-1]}"    "${COMP_WORDS[${#COMP_WORDS[@]}-2]}"
  3320.             else
  3321.                 $func $cmd "${COMP_WORDS[${#COMP_WORDS[@]}-1]}"
  3322.             fi
  3323.  
  3324.             # remove any \: generated by a command that doesn't
  3325.             # default to filenames or dirnames (e.g. sudo chown)
  3326.             # FIXME: I'm pretty sure this does not work!
  3327.             if [ "${cspec#*-o }" != "$cspec" ]; then
  3328.                 cspec=${cspec#*-o }
  3329.                 cspec=${cspec%% *}
  3330.                 if [[ "$cspec" != @(dir|file)names ]]; then
  3331.                     COMPREPLY=("${COMPREPLY[@]//\\\\:/:}")
  3332.                 fi
  3333.             fi
  3334.         elif [ -n "$cspec" ]; then
  3335.             cspec=${cspec#complete};
  3336.             cspec=${cspec%%$cmd};
  3337.             COMPREPLY=( $( eval compgen "$cspec" -- "$cur" ) );
  3338.         fi
  3339.         fi
  3340.     fi
  3341.  
  3342.     [ ${#COMPREPLY[@]} -eq 0 ] && _filedir
  3343. }
  3344. complete -F _command $filenames nohup exec nice eval time ltrace then \
  3345.     else do vsound command xargs tsocks
  3346.  
  3347. _root_command()
  3348. {
  3349.     PATH=$PATH:/sbin:/usr/sbin:/usr/local/sbin _command $1 $2 $3
  3350. }
  3351. complete -F _root_command $filenames sudo fakeroot really gksudo gksu kdesudo
  3352.  
  3353. # ant(1) completion
  3354. #
  3355. have ant && {
  3356. _ant()
  3357. {
  3358.     local cur prev buildfile i
  3359.  
  3360.     COMPREPLY=()
  3361.     cur=`_get_cword`
  3362.     prev=${COMP_WORDS[COMP_CWORD-1]}
  3363.  
  3364.     case "$prev" in
  3365.         -buildfile|-f)
  3366.             _filedir 'xml'
  3367.             return 0
  3368.             ;;
  3369.         -logfile)
  3370.             _filedir
  3371.             return 0
  3372.             ;;
  3373.     esac
  3374.  
  3375.     if [[ "$cur" == -* ]]; then
  3376.         # relevant options completion
  3377.         COMPREPLY=( $( compgen -W '-help -projecthelp -version -quiet \
  3378.                    -verbose -debug -emacs -logfile -logger \
  3379.                    -listener -buildfile -f -D -find' -- $cur ) )
  3380.     else
  3381.         # available targets completion
  3382.         # find which buildfile to use
  3383.         buildfile=build.xml
  3384.         for (( i=1; i < COMP_CWORD; i++ )); do
  3385.             if [[ "${COMP_WORDS[i]}" == -buildfile ]]; then
  3386.                 buildfile=${COMP_WORDS[i+1]}
  3387.                 break
  3388.             fi
  3389.         done
  3390.         [ ! -f $buildfile ] && return 0
  3391.  
  3392.         # parse buildfile for targets
  3393.         COMPREPLY=( $( awk -F'"' '/<target name="/ {print $2}' \
  3394.                 $buildfile | grep "^$cur" )
  3395.                 $( awk -F"'" "/<target name='/ "'{print $2}' \
  3396.                 $buildfile | grep "^$cur" )
  3397.                 $( awk -F'"' '/<target [^n]/ {if ($1 ~ /name=/) { print $2 } else if ($3 ~ /name=/) {print $4} else if ($5 ~ /name=/) {print $6}}' \
  3398.                 $buildfile | grep "^$cur" ) )
  3399.     fi
  3400. }
  3401. have complete-ant-cmd.pl && \
  3402.      complete -C complete-ant-cmd.pl -F _ant $filenames ant || \
  3403.      complete -F _ant $filenames ant
  3404. }
  3405.  
  3406. have nslookup &&
  3407. _nslookup()
  3408. {
  3409.     local cur
  3410.  
  3411.     COMPREPLY=()
  3412.     cur=${COMP_WORDS[COMP_CWORD]#-}
  3413.  
  3414.     COMPREPLY=( $( compgen -P '-' -W 'all class= debug d2 domain= \
  3415.                    srchlist= defname search port= querytype= \
  3416.                    type= recurse retry root timeout vc \
  3417.                    ignoretc' -- $cur ) )
  3418. } &&
  3419. complete -F _nslookup nslookup
  3420.  
  3421. # mysqladmin(1) completion
  3422. #
  3423. have mysqladmin &&
  3424. _mysqladmin()
  3425. {
  3426.     local cur prev
  3427.  
  3428.     COMPREPLY=()
  3429.     cur=`_get_cword`
  3430.     prev=${COMP_WORDS[COMP_CWORD-1]}
  3431.  
  3432.     case "$prev" in
  3433.     -u)
  3434.         COMPREPLY=( $( compgen -u -- $cur ) )
  3435.         return 0
  3436.         ;;
  3437.     *)
  3438.         ;;
  3439.     esac
  3440.  
  3441.     COMPREPLY=( $( compgen -W '-# -f -? -C -h -p -P -i -r -E -s -S -t -u \
  3442.                           -v -V -w' -- $cur ) )
  3443.  
  3444.     COMPREPLY=( "${COMPREPLY[@]}" \
  3445.             $( compgen -W 'create drop extended-status flush-hosts \
  3446.                    flush-logs flush-status flush-tables \
  3447.                    flush-threads flush-privileges kill \
  3448.                    password ping processlist reload refresh \
  3449.                    shutdown status variables version' \
  3450.                -- $cur ) )
  3451. } &&
  3452. complete -F _mysqladmin mysqladmin
  3453.  
  3454. # gzip(1) completion
  3455. #
  3456. have gzip &&
  3457. _gzip()
  3458. {
  3459.     local cur prev xspec helpopts
  3460.  
  3461.     COMPREPLY=()
  3462.     cur=`_get_cword`
  3463.     prev=${COMP_WORDS[COMP_CWORD-1]}
  3464.     helpopts=`_parse_help gzip`
  3465.  
  3466.     if [[ "$cur" == -* ]]; then
  3467.         COMPREPLY=( $( compgen -W "$helpopts -2 -3 -4 -5 -6 -7 -8" \
  3468.                         -- "$cur" ) )
  3469.         return 0
  3470.     fi
  3471.  
  3472.     local IFS=$'\t\n'
  3473.  
  3474.     xspec="*.?(t)gz"
  3475.     if [[ "$prev" == --* ]]; then
  3476.         [[ "$prev" == --decompress || \
  3477.             "$prev" == --list || \
  3478.             "$prev" == --test ]] && xspec="!"$xspec
  3479.         [[ "$prev" == --force ]] && xspec=
  3480.     elif [[ "$prev" == -* ]]; then
  3481.         [[ "$prev" == -*[dlt]* ]] && xspec="!"$xspec
  3482.         [[ "$prev" == -*f* ]] && xspec=
  3483.     elif [ "$prev" = '>' -o "$prev" = '>>' ]; then
  3484.         xspec=
  3485.     elif [ "$prev" = '<' ]; then
  3486.         xspec=
  3487.     fi
  3488.  
  3489.     _expand || return 0
  3490.  
  3491.     COMPREPLY=( $( compgen -f -X "$xspec" -- $cur ) \
  3492.             $( compgen -d -- $cur ) )
  3493. } &&
  3494. complete -F _gzip $filenames gzip
  3495.  
  3496. # bzip2(1) completion
  3497. #
  3498. have bzip2 &&
  3499. _bzip2()
  3500. {
  3501.     local cur prev xspec
  3502.  
  3503.     COMPREPLY=()
  3504.     cur=`_get_cword`
  3505.     prev=${COMP_WORDS[COMP_CWORD-1]}
  3506.  
  3507.     if [[ "$cur" == -* ]]; then
  3508.         COMPREPLY=( $( compgen -W '-c -d -f -h -k -L -q -s \
  3509.             -t -v -V -z -1 -2 -3 -4 -5 -6 -7 -8 -9 \
  3510.             --help --decompress --compress --keep --force \
  3511.             --test --stdout --quiet --verbose --license \
  3512.             --version --small --fast --best' -- $cur ) )
  3513.         return 0
  3514.     fi
  3515.  
  3516.     local IFS=$'\t\n'
  3517.  
  3518.     xspec="*.bz2"
  3519.     if [[ "$prev" == --* ]]; then
  3520.         [[ "$prev" == --decompress || \
  3521.             "$prev" == --list || \
  3522.             "$prev" == --test ]] && xspec="!"$xspec
  3523.         [[ "$prev" == --compress ]] && xspec=
  3524.     elif [[ "$prev" == -* ]]; then
  3525.         [[ "$prev" == -*[dt]* ]] && xspec="!"$xspec
  3526.         [[ "$prev" == -*z* ]] && xspec=
  3527.     fi
  3528.  
  3529.     _expand || return 0
  3530.  
  3531.     COMPREPLY=( $( compgen -f -X "$xspec" -- $cur ) \
  3532.             $( compgen -d -- $cur ) )
  3533. } &&
  3534. complete -F _bzip2 $filenames bzip2
  3535.  
  3536. # openssl(1) completion
  3537. #
  3538. have openssl && {
  3539. _openssl_sections()
  3540. {
  3541.     local config
  3542.  
  3543.     config=/etc/ssl/openssl.cnf
  3544.     [ ! -f $config ] && config=/usr/share/ssl/openssl.cnf
  3545.     for (( i=2; i < COMP_CWORD; i++ )); do
  3546.         if [[ "${COMP_WORDS[i]}" == -config ]]; then
  3547.             config=${COMP_WORDS[i+1]}
  3548.             break
  3549.         fi
  3550.     done
  3551.     [ ! -f $config ] && return 0
  3552.  
  3553.     COMPREPLY=( $( awk '/\[.*\]/ {print $2} ' $config | grep "^$cur" ) )
  3554. }
  3555.  
  3556. _openssl()
  3557. {
  3558.     local cur prev
  3559.  
  3560.     COMPREPLY=()
  3561.     cur=`_get_cword`
  3562.  
  3563.     if [ $COMP_CWORD -eq 1 ]; then
  3564.         COMPREPLY=( $( compgen -W 'asn1parse ca ciphers crl crl2pkcs7 \
  3565.             dgst dh dhparam dsa dsaparam enc errstr gendh gendsa \
  3566.             genrsa nseq passwd pkcs12 pkcs7 pkcs8 rand req rsa \
  3567.             rsautl s_client s_server s_time sess_id smime speed \
  3568.             spkac verify version x509 md2 md4 md5 mdc2 rmd160 sha \
  3569.             sha1 base64 bf bf-cbc bf-cfb bf-ecb bf-ofb cast \
  3570.             cast-cbc cast5-cbc cast5-cfb cast5-ecb cast5-ofb des \
  3571.             des-cbc des-cfb des-ecb des-ede des-ede-cbc \
  3572.             des-ede-cfb des-ede-ofb des-ede3 des-ede3-cbc \
  3573.             des-ede3-cfb des-ede3-ofb des-ofb des3 desx rc2 \
  3574.             rc2-40-cbc rc2-64-cbc rc2-cbc rc2-cfb rc2-ecb rc2-ofb \
  3575.             rc4 rc4-40' -- $cur ) )
  3576.     else
  3577.         prev=${COMP_WORDS[COMP_CWORD-1]}
  3578.         case ${COMP_WORDS[1]} in
  3579.             asn1parse)
  3580.                 case $prev in
  3581.                     -inform)
  3582.                         COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  3583.                         return 0
  3584.                         ;;
  3585.                     -@(in|out|oid))
  3586.                         _filedir
  3587.                         return 0
  3588.                         ;;
  3589.                     esac
  3590.  
  3591.                 if [[ "$cur" == -* ]]; then
  3592.                     COMPREPLY=( $( compgen -W '-inform -in -out -noout -offset \
  3593.                         -length -i -oid -strparse' -- $cur ) )
  3594.                 fi
  3595.                 ;;
  3596.             ca)
  3597.                 case $prev in
  3598.                     -@(config|revoke|cert|in|out|spkac|ss_cert))
  3599.                         _filedir
  3600.                         return 0
  3601.                         ;;
  3602.                     -outdir)
  3603.                         _filedir -d
  3604.                         return 0
  3605.                         ;;
  3606.                     -@(name|crlexts|extensions))
  3607.                         _openssl_sections
  3608.                         return 0
  3609.                         ;;
  3610.                 esac
  3611.  
  3612.                 if [[ "$cur" == -* ]]; then
  3613.                     COMPREPLY=( $( compgen -W '-verbose -config -name \
  3614.                         -gencrl -revoke -crldays -crlhours -crlexts \
  3615.                         -startdate -enddate -days -md -policy -keyfile \
  3616.                         -key -passin -cert -in -out -notext -outdir \
  3617.                         -infiles -spkac -ss_cert -preserveDN -batch \
  3618.                         -msie_hack -extensions' -- $cur ) )
  3619.                 fi
  3620.                 ;;
  3621.             ciphers)
  3622.                 if [[ "$cur" == -* ]]; then
  3623.                     COMPREPLY=( $( compgen -W '-v -ssl2 -ssl3 -tls1' -- $cur ) )
  3624.                 fi
  3625.                 ;;
  3626.             crl)
  3627.                 case $prev in
  3628.                     -@(in|out)form)
  3629.                         COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  3630.                         return 0
  3631.                         ;;
  3632.                     -@(in|out|CAfile))
  3633.                         _filedir
  3634.                         return 0
  3635.                         ;;
  3636.                     -CAPath)
  3637.                         _filedir -d
  3638.                         return 0
  3639.                         ;;
  3640.                 esac
  3641.  
  3642.                 if [[ "$cur" == -* ]]; then
  3643.                     COMPREPLY=( $( compgen -W '-inform -outform -text -in -out -noout \
  3644.                         -hash -issuer -lastupdate -nextupdate -CAfile -CApath' -- $cur ) )
  3645.                 fi
  3646.                 ;;
  3647.             crl2pkcs7)
  3648.                 case $prev in
  3649.                     -@(in|out)form)
  3650.                         COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  3651.                         return 0
  3652.                         ;;
  3653.                     -@(in|out))
  3654.                         _filedir
  3655.                         return 0
  3656.                         ;;
  3657.                 esac
  3658.  
  3659.                 if [[ "$cur" == -* ]]; then
  3660.                     COMPREPLY=( $( compgen -W '-inform -outform -in -out -print_certs' -- $cur ) )
  3661.                 fi
  3662.                 ;;
  3663.             dgst)
  3664.                 case $prev in
  3665.                     -@(out|sign|verify|prvrify|signature))
  3666.                         _filedir
  3667.                         return 0
  3668.                         ;;
  3669.                 esac
  3670.  
  3671.                 if [[ "$cur" == -* ]]; then
  3672.                     COMPREPLY=( $( compgen -W '-md5 -md4 -md2 -sha1 -sha -mdc2 -ripemd160 -dss1 \
  3673.                         -c -d -hex -binary -out -sign -verify -prverify -signature' -- $cur ) )
  3674.                 else
  3675.                         _filedir
  3676.                 fi
  3677.                    ;;
  3678.             dsa)
  3679.                 case $prev in
  3680.                     -@(in|out)form)
  3681.                         COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  3682.                         return 0
  3683.                         ;;
  3684.                     -@(in|out))
  3685.                         _filedir
  3686.                         return 0
  3687.                         ;;
  3688.                 esac
  3689.  
  3690.                 if [[ "$cur" == -* ]]; then
  3691.                     COMPREPLY=( $( compgen -W '-inform -outform -in -passin -out -passout -des -des3 -idea -text -noout \
  3692.                         -modulus -pubin -pubout' -- $cur ) )
  3693.                 fi
  3694.                 ;;
  3695.             dsaparam)
  3696.                 case $prev in
  3697.                     -@(in|out)form)
  3698.                         COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  3699.                         return 0
  3700.                         ;;
  3701.                     -@(in|out|rand))
  3702.                         _filedir
  3703.                         return 0
  3704.                         ;;
  3705.                 esac
  3706.  
  3707.                 if [[ "$cur" == -* ]]; then
  3708.                     COMPREPLY=( $( compgen -W '-inform -outform -in -out -noout \
  3709.                         -text -C -rand -genkey' -- $cur ) )
  3710.                 fi
  3711.                 ;;
  3712.             enc)
  3713.                 case $prev in
  3714.                     -@(in|out|kfile))
  3715.                         _filedir
  3716.                         return 0
  3717.                         ;;
  3718.                 esac
  3719.  
  3720.                 if [[ "$cur" == -* ]]; then
  3721.                     COMPREPLY=( $( compgen -W '-ciphername -in -out -pass \
  3722.                         -e -d -a -A -k -kfile -S -K -iv -p -P -bufsize -debug' -- $cur ) )
  3723.                 fi
  3724.                 ;;
  3725.             dhparam)
  3726.                 case $prev in
  3727.                     -@(in|out)form)
  3728.                         COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  3729.                         return 0
  3730.                         ;;
  3731.                     -@(in|out|rand))
  3732.                         _filedir
  3733.                         return 0
  3734.                         ;;
  3735.                 esac
  3736.  
  3737.                 if [[ "$cur" == -* ]]; then
  3738.                     COMPREPLY=( $( compgen -W '-inform -outform -in -out -dsaparam -noout \
  3739.                         -text -C -2 -5 -rand' -- $cur ) )
  3740.                 fi
  3741.                 ;;
  3742.             gendsa)
  3743.                 case $prev in
  3744.                     -@(out|rand))
  3745.                         _filedir
  3746.                         return 0
  3747.                         ;;
  3748.                 esac
  3749.  
  3750.                 if [[ "$cur" == -* ]]; then
  3751.                     COMPREPLY=( $( compgen -W '-out -des -des3 -idea -rand' -- $cur ) )
  3752.                 else
  3753.                         _filedir
  3754.                 fi
  3755.                 ;;
  3756.             genrsa)
  3757.                 case $prev in
  3758.                     -@(out|rand))
  3759.                         _filedir
  3760.                         return 0
  3761.                         ;;
  3762.                 esac
  3763.  
  3764.                 if [[ "$cur" == -* ]]; then
  3765.                     COMPREPLY=( $( compgen -W '-out -passout -des -des3 -idea -f4 -3 -rand' -- $cur ) )
  3766.                 fi
  3767.                 ;;
  3768.             pkcs7)
  3769.                 case $prev in
  3770.                     -@(in|out)form)
  3771.                         COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  3772.                         return 0
  3773.                         ;;
  3774.                     -@(in|out))
  3775.                         _filedir
  3776.                         return 0
  3777.                         ;;
  3778.                 esac
  3779.  
  3780.                 if [[ "$cur" == -* ]]; then
  3781.                     COMPREPLY=( $( compgen -W '-inform -outform -in -out -print_certs -text -noout' -- $cur ) )
  3782.                 fi
  3783.                 ;;
  3784.             rand)
  3785.                 case $prev in
  3786.                     -@(out|rand))
  3787.                         _filedir
  3788.                         return 0
  3789.                         ;;
  3790.                 esac
  3791.  
  3792.                 if [[ "$cur" == -* ]]; then
  3793.                     COMPREPLY=( $( compgen -W '-out -rand -base64' -- $cur ) )
  3794.                 fi
  3795.                 ;;
  3796.             req)
  3797.                 case "$prev" in
  3798.                     -@(in|out|key)form)
  3799.                         COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  3800.                         return 0
  3801.                         ;;
  3802.  
  3803.                     -@(in|out|rand|key|keyout|config))
  3804.                         _filedir
  3805.                         return 0
  3806.                         ;;
  3807.                     -extensions)
  3808.                         _openssl_sections
  3809.                         return 0
  3810.                         ;;
  3811.                 esac
  3812.  
  3813.                 if [[ "$cur" == -* ]]; then
  3814.                     COMPREPLY=( $( compgen -W '-inform -outform -in \
  3815.                         -passin -out -passout -text -noout -verify \
  3816.                         -modulus -new -rand -newkey -newkey -nodes \
  3817.                         -key -keyform -keyout -md5 -sha1 -md2 -mdc2 \
  3818.                         -config -x509 -days -asn1-kludge -newhdr \
  3819.                         -extensions -reqexts section' -- $cur ) )
  3820.                 fi
  3821.                 ;;
  3822.             rsa)
  3823.                 case $prev in
  3824.                     -@(in|out)form)
  3825.                         COMPREPLY=( $( compgen -W 'DER NET PEM' -- $cur ) )
  3826.                         return 0
  3827.                         ;;
  3828.                     -@(in|out))
  3829.                         _filedir
  3830.                         return 0
  3831.                         ;;
  3832.                 esac
  3833.  
  3834.                 if [[ "$cur" == -* ]]; then
  3835.                     COMPREPLY=( $( compgen -W '-inform -outform -in -passin -out -passout \
  3836.                         -sgckey -des -des3 -idea -text -noout -modulus -check -pubin \
  3837.                         -pubout -engine' -- $cur ) )
  3838.                 fi
  3839.                 ;;
  3840.             rsautl)
  3841.                 case $prev in
  3842.                     -@(in|out|inkey))
  3843.                         _filedir
  3844.                         return 0
  3845.                         ;;
  3846.                 esac
  3847.  
  3848.                 if [[ "$cur" == -* ]]; then
  3849.                     COMPREPLY=( $( compgen -W '-in -out -inkey -pubin -certin -sign -verify \
  3850.                         -encrypt -decrypt -pkcs -ssl -raw -hexdump -asn1parse' -- $cur ) )
  3851.                 fi
  3852.                 ;;
  3853.             s_client)
  3854.                 case $prev in
  3855.                     -connect)
  3856.                         _known_hosts
  3857.                         return 0
  3858.                         ;;
  3859.                     -@(cert|key|CAfile|rand))
  3860.                         _filedir
  3861.                         return 0
  3862.                         ;;
  3863.                     -CApath)
  3864.                         _filedir -d
  3865.                         return 0
  3866.                         ;;
  3867.                 esac
  3868.  
  3869.                 if [[ "$cur" == -* ]]; then
  3870.                     COMPREPLY=( $( compgen -W '-connect -verify -cert -key -CApath -CAfile \
  3871.                         -reconnect -pause -showcerts -debug -msg -nbio_test -state -nbio \
  3872.                         -crlf -ign_eof -quiet -ssl2 -ssl3 -tls1 -no_ssl2 -no_ssl3 -no_tls1 \
  3873.                         -bugs -cipher -starttls -engine -rand' -- $cur ) )
  3874.                 fi
  3875.                 ;;
  3876.             s_server)
  3877.                 case $prev in
  3878.                     -@(cert|key|dcert|dkey|dhparam|CAfile|rand))
  3879.                         _filedir
  3880.                         return 0
  3881.                         ;;
  3882.                     -CApath)
  3883.                         _filedir -d
  3884.                         return 0
  3885.                         ;;
  3886.                 esac
  3887.  
  3888.                 if [[ "$cur" == -* ]]; then
  3889.                     COMPREPLY=( $( compgen -W '-accept -context -verify -Verify -cert -key \
  3890.                          -dcert -dkey -dhparam -nbio -nbio_test -crlf -debug -msg -state -CApath \
  3891.                          -CAfile -nocert -cipher -quiet -no_tmp_rsa -ssl2 -ssl3 -tls1 -no_ssl2 \
  3892.                          -no_ssl3 -no_tls1 -no_dhe -bugs -hack -www -WWW -HTTP -engine -id_prefix \
  3893.                          -rand' -- $cur ) )
  3894.                  fi
  3895.                  ;;
  3896.             s_time)
  3897.                 case $prev in
  3898.                     -connect)
  3899.                         _known_hosts
  3900.                         return 0
  3901.                         ;;
  3902.                     -@(cert|key|CAfile))
  3903.                         _filedir
  3904.                         return 0
  3905.                         ;;
  3906.                     -CApath)
  3907.                         _filedir -d
  3908.                         return 0
  3909.                         ;;
  3910.                 esac
  3911.  
  3912.                 if [[ "$cur" == -* ]]; then
  3913.                     COMPREPLY=( $( compgen -W '-connect -www -cert -key -CApath -CAfile -reuse \
  3914.                         -new -verify -nbio -time -ssl2 -ssl3 -bugs -cipher' -- $cur ) )
  3915.                 fi
  3916.                 ;;
  3917.  
  3918.             sess_id)
  3919.                 case $prev in
  3920.                     -@(in|out)form)
  3921.                         COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  3922.                         return 0
  3923.                         ;;
  3924.                     -@(in|out))
  3925.                         _filedir
  3926.                         return 0
  3927.                         ;;
  3928.                 esac
  3929.  
  3930.  
  3931.                 if [[ "$cur" == -* ]]; then
  3932.                     COMPREPLY=( $( compgen -W '-inform -outform -in -out -text -noout \
  3933.                         -context ID' -- $cur ) )
  3934.                 fi
  3935.                 ;;
  3936.             smime)
  3937.                 case $prev in
  3938.                     -@(in|out)form)
  3939.                         COMPREPLY=( $( compgen -W 'SMIME DER PEM' -- $cur ) )
  3940.                         return 0
  3941.                         ;;
  3942.                     -@(in|out|certfile|signer|recip|inkey|content|rand))
  3943.                         _filedir
  3944.                         return 0
  3945.                         ;;
  3946.                 esac
  3947.  
  3948.                 if [[ "$cur" == -* ]]; then
  3949.                     COMPREPLY=( $( compgen -W '-encrypt -decrypt -sign -verify -pk7out -des -des3 \
  3950.                         -rc2-40 -rc2-64 -rc2-128 -aes128 -aes192 -aes256 -in -certfile -signer \
  3951.                         -recip -inform -passin -inkey -out -outform -content -to -from -subject \
  3952.                         -text -rand' -- $cur ) )
  3953.                 else
  3954.                         _filedir
  3955.                 fi
  3956.                 ;;
  3957.             speed)
  3958.                 if [[ "$cur" == -* ]]; then
  3959.                     COMPREPLY=( $( compgen -W '-engine' -- $cur ) )
  3960.                 else
  3961.                     COMPREPLY=( $( compgen -W 'md2 mdc2 md5 hmac sha1 rmd160 idea-cbc \
  3962.                         rc2-cbc rc5-cbc bf-cbc des-cbc des-ede3 rc4 rsa512 rsa1024 rsa2048 \
  3963.                         rsa4096 dsa512 dsa1024 dsa2048 idea rc2 des rsa blowfish' -- $cur ) )
  3964.                 fi
  3965.                 ;;
  3966.             verify)
  3967.                 case $prev in
  3968.                     -@(CAfile|untrusted))
  3969.                         _filedir
  3970.                         return 0
  3971.                         ;;
  3972.                     -CApath)
  3973.                         _filedir -d
  3974.                         return 0
  3975.                         ;;
  3976.                 esac
  3977.  
  3978.                 if [[ "$cur" == -* ]]; then
  3979.                     COMPREPLY=( $( compgen -W '-CApath -CAfile -purpose -untrusted -help -issuer_checks \
  3980.                         -verbose -certificates' -- $cur ) )
  3981.                 else
  3982.                         _filedir
  3983.                 fi
  3984.                 ;;
  3985.             x509)
  3986.                 case "$prev" in
  3987.                     -@(in|out|CA|CAkey|CAserial|extfile))
  3988.                         _filedir
  3989.                         return 0
  3990.                         ;;
  3991.                     -@(in|out)form)
  3992.                         COMPREPLY=( $( compgen -W 'DER PEM NET' -- $cur ) )
  3993.                         return 0
  3994.                         ;;
  3995.                     -@(key|CA|CAkey)form)
  3996.                         COMPREPLY=( $( compgen -W 'DER PEM' -- $cur ) )
  3997.                         return 0
  3998.                         ;;
  3999.                     -extensions)
  4000.                         _openssl_sections
  4001.                         return 0
  4002.                         ;;
  4003.                 esac
  4004.  
  4005.                 if [[ "$cur" == -* ]]; then
  4006.                     COMPREPLY=( $( compgen -W '-inform -outform \
  4007.                         -keyform -CAform -CAkeyform -in -out \
  4008.                         -serial -hash -subject -issuer -nameopt \
  4009.                         -email -startdate -enddate -purpose \
  4010.                         -dates -modulus -fingerprint -alias \
  4011.                         -noout -trustout -clrtrust -clrreject \
  4012.                         -addtrust -addreject -setalias -days \
  4013.                         -set_serial -signkey -x509toreq -req \
  4014.                         -CA -CAkey -CAcreateserial -CAserial \
  4015.                         -text -C -md2 -md5 -sha1 -mdc2 -clrext \
  4016.                         -extfile -extensions -engine' -- $cur ) )
  4017.                 fi
  4018.                 ;;
  4019.             @(md5|md4|md2|sha1|sha|mdc2|ripemd160))
  4020.                 if [[ "$cur" == -* ]]; then
  4021.                     COMPREPLY=( $( compgen -W '-c -d' -- $cur ) )
  4022.                 else
  4023.                         _filedir
  4024.                 fi
  4025.                 ;;
  4026.         esac
  4027.     fi
  4028.  
  4029.     return 0
  4030. }
  4031. complete -F _openssl $default openssl
  4032. }
  4033.  
  4034. # screen(1) completion
  4035. #
  4036. have screen &&
  4037. _screen()
  4038. {
  4039.     local cur prev preprev
  4040.  
  4041.     COMPREPLY=()
  4042.     cur=`_get_cword`
  4043.     prev=${COMP_WORDS[COMP_CWORD-1]}
  4044.  
  4045.     [ "$COMP_CWORD" -ge 2 ] && preprev=${COMP_WORDS[COMP_CWORD-2]}
  4046.  
  4047.     if [ "$preprev" = "-d" -o "$preprev" = "-D" -a "$prev" = "-r" -o \
  4048.          "$prev" = "-R" ]; then
  4049.         # list all
  4050.         COMPREPLY=( $( command screen -ls | \
  4051.                 sed -ne 's|^['$'\t'']\+\('$cur'[0-9]\+\.[^'$'\t'']\+\).*$|\1|p' ) )
  4052.     else
  4053.         case "$prev" in
  4054.         -[rR])
  4055.             # list detached
  4056.             COMPREPLY=( $( command screen -ls | \
  4057.                     sed -ne 's|^['$'\t'']\+\('$cur'[0-9]\+\.[^'$'\t'']\+\).*Detached.*$|\1|p' ) )
  4058.             ;;
  4059.         -[dDx])
  4060.             # list attached
  4061.             COMPREPLY=( $( command screen -ls | \
  4062.                     sed -ne 's|^['$'\t'']\+\('$cur'[0-9]\+\.[^'$'\t'']\+\).*Attached.*$|\1|p' ) )
  4063.             ;;
  4064.         -s)
  4065.             # shells
  4066.             COMPREPLY=( $( grep ^${cur:-[^#]} /etc/shells ) )
  4067.             ;;
  4068.         *)
  4069.             ;;
  4070.         esac
  4071.     fi
  4072.  
  4073.     return 0
  4074. } &&
  4075. complete -F _screen $default screen
  4076.  
  4077. # lftp(1) bookmark completion
  4078. #
  4079. have lftp &&
  4080. _lftp()
  4081. {
  4082.     local cur
  4083.  
  4084.     COMPREPLY=()
  4085.     cur=`_get_cword`
  4086.  
  4087.     if [ $COMP_CWORD -eq 1 ] && [ -f ~/.lftp/bookmarks ]; then
  4088.         COMPREPLY=( $( compgen -W '$( sed -ne "s/^\(.*\)'$'\t''.*$/\1/p" \
  4089.                ~/.lftp/bookmarks )' -- $cur ) )
  4090.     fi
  4091.  
  4092.     return 0
  4093. } &&
  4094. complete -F _lftp $default lftp
  4095.  
  4096. # ncftp(1) bookmark completion
  4097. #
  4098. have ncftp &&
  4099. _ncftp()
  4100. {
  4101.     local cur
  4102.  
  4103.     COMPREPLY=()
  4104.     cur=`_get_cword`
  4105.  
  4106.     if [ $COMP_CWORD -eq 1 ] && [ -f ~/.ncftp/bookmarks ]; then
  4107.         COMPREPLY=( $( compgen -W '$( sed -ne "s/^\([^,]\{1,\}\),.*$/\1/p" \
  4108.                ~/.ncftp/bookmarks )' -- $cur ) )
  4109.     fi
  4110.  
  4111.     return 0
  4112. } &&
  4113. complete -F _ncftp $default ncftp
  4114.  
  4115. # gdb(1) completion
  4116. #
  4117. have gdb &&
  4118. _gdb()
  4119. {
  4120.     local cur prev
  4121.  
  4122.     COMPREPLY=()
  4123.     cur=`_get_cword`
  4124.     prev=${COMP_WORDS[COMP_CWORD-1]}
  4125.  
  4126.     if [ $COMP_CWORD -eq 1 ]; then
  4127.         local IFS
  4128.         if [[ "$cur" == */* ]]; then
  4129.             # compgen -c works as expected if $cur contains any slashes.
  4130.             IFS=$'\n'
  4131.             COMPREPLY=( $( PATH="$PATH:." compgen -d -c -- "$cur" ) )
  4132.         else
  4133.             # otherwise compgen -c contains Bash's built-in commands,
  4134.             # functions and aliases. Thus we need to retrieve the program
  4135.             # names manually.
  4136.             IFS=":"
  4137.             local path_array=( $(echo "$PATH" | sed 's/::\+/:/g;s/^:\|:$//g') )
  4138.             IFS=$'\n'
  4139.             COMPREPLY=( $( compgen -d -W '$(find "${path_array[@]}" . \
  4140.                 -mindepth 1 -maxdepth 1 -not -type d -executable -printf "%f\\n" 2>/dev/null)' \
  4141.                 -- "$cur" ) )
  4142.         fi
  4143.     elif [ $COMP_CWORD -eq 2 ]; then
  4144.         prev=${prev##*/}
  4145.         COMPREPLY=( $( compgen -fW "$( command ps axo comm,pid | \
  4146.                 awk '{if ($1 ~ /^'"$prev"'/) print $2}' ) )" \
  4147.                 -- "$cur" ) )
  4148.     fi
  4149. } &&
  4150. complete -F _gdb $default gdb
  4151.  
  4152. # Postgresql completion
  4153. #
  4154. have psql && {
  4155. _pg_databases()
  4156. {
  4157.     return
  4158.     COMPREPLY=( $( psql -l 2>/dev/null | \
  4159.             sed -e '1,/^-/d' -e '/^(/,$d' | \
  4160.             awk '{print $1}' | grep "^$cur" ) )
  4161. }
  4162.  
  4163. _pg_users()
  4164. {
  4165.     #COMPREPLY=( $( psql -qtc 'select usename from pg_user' template1 2>/dev/null | \
  4166.     #        grep "^ $cur" ) )
  4167.     #[ ${#COMPREPLY[@]} -eq 0 ] && COMPREPLY=( $( compgen -u -- $cur ) )
  4168.     COMPREPLY=( $( compgen -u -- $cur ) )
  4169. }
  4170.  
  4171. # createdb(1) completion
  4172. #
  4173. _createdb()
  4174. {
  4175.     local cur prev
  4176.  
  4177.     COMPREPLY=()
  4178.     cur=`_get_cword`
  4179.     prev=${COMP_WORDS[COMP_CWORD-1]}
  4180.  
  4181.     case "$prev" in
  4182.     -@(h|-host=))
  4183.         _known_hosts
  4184.         return 0
  4185.         ;;
  4186.     -@(U|-username=))
  4187.         _pg_users
  4188.         return 0
  4189.         ;;
  4190.     esac
  4191.  
  4192.     if [[ "$cur" == -* ]]; then
  4193.         COMPREPLY=( $( compgen -W '-D -T -E -h -p -U -W -e -q \
  4194.             --location= --template= --encoding= --host= --port= \
  4195.             --username= --password --echo --quiet --help' -- $cur ))
  4196.     else
  4197.         _pg_databases
  4198.     fi
  4199. }
  4200. complete -F _createdb $default createdb
  4201.  
  4202. # dropdb(1) completion
  4203. #
  4204. _dropdb()
  4205. {
  4206.     local cur prev
  4207.  
  4208.     COMPREPLY=()
  4209.     cur=`_get_cword`
  4210.     prev=${COMP_WORDS[COMP_CWORD-1]}
  4211.  
  4212.     case "$prev" in
  4213.     -@(h|-host=))
  4214.         _known_hosts
  4215.         return 0
  4216.         ;;
  4217.     -@(U|-username=))
  4218.         _pg_users
  4219.         return 0
  4220.         ;;
  4221.     esac
  4222.  
  4223.     if [[ "$cur" == -* ]]; then
  4224.         COMPREPLY=( $( compgen -W '-h -p -U -W -e -q \
  4225.                 --host= --port= --username= --password \
  4226.                 --interactive --echo --quiet --help' -- $cur ) )
  4227.     else
  4228.         _pg_databases
  4229.     fi
  4230. }
  4231. complete -F _dropdb $default dropdb
  4232.  
  4233. # psql(1) completion
  4234. #
  4235. _psql()
  4236. {
  4237.     local cur prev
  4238.  
  4239.     COMPREPLY=()
  4240.     cur=`_get_cword`
  4241.     prev=${COMP_WORDS[COMP_CWORD-1]}
  4242.  
  4243.     case "$prev" in
  4244.     -h|--host)
  4245.         _known_hosts
  4246.         return 0
  4247.         ;;
  4248.     -U|--username)
  4249.         _pg_users
  4250.         return 0
  4251.         ;;
  4252.     -d|--dbname)
  4253.         _pg_databases
  4254.         return 0
  4255.         ;;
  4256.     -@(o|f)|--output|--file)
  4257.         _filedir
  4258.         return 0
  4259.         ;;
  4260.     esac
  4261.  
  4262.     if [[ "$cur" == -* ]]; then
  4263.         # return list of available options
  4264.         COMPREPLY=( $( compgen -W '-a --echo-all -A --no-align \
  4265.             -c --command -d --dbname -e --echo-queries \
  4266.             -E --echo-hidden -f --file -F --filed-separator \
  4267.             -h --host -H --html -l --list -n -o --output \
  4268.             -p --port -P --pset -q -R --record-separator \
  4269.             -s --single-step -S --single-line -t --tuples-only \
  4270.             -T --table-attr -U --username -v --variable \
  4271.             -V --version -W --password -x --expanded -X --nopsqlrc \
  4272.             -? --help ' -- $cur ) )
  4273.     else
  4274.         # return list of available databases
  4275.         _pg_databases
  4276.     fi
  4277. }
  4278. complete -F _psql $default psql
  4279. }
  4280.  
  4281. _longopt()
  4282. {
  4283.     local cur opt
  4284.  
  4285.     cur=`_get_cword`
  4286.  
  4287.     if [[ "$cur" == --*=* ]]; then
  4288.         opt=${cur%%=*}
  4289.         # cut backslash that gets inserted before '=' sign
  4290.         opt=${opt%\\*}
  4291.         cur=${cur#*=}
  4292.         _filedir
  4293.         # FIXME: see #297065... adding "-o nospace" (or $nospace),
  4294.         # should do the trick, but seems not working... ideas?
  4295.         COMPREPLY=( $( compgen -P "$opt=" -W '${COMPREPLY[@]}' -- $cur))
  4296.         return 0
  4297.     fi
  4298.  
  4299.     if [[ "$cur" == -* ]]; then
  4300.         COMPREPLY=( $( $1 --help 2>&1 | sed -e '/--/!d' \
  4301.                 -e 's/.*\(--[-A-Za-z0-9]\+=\?\).*/\1/' | \
  4302.                    command grep "^$cur" | sort -u ) )
  4303.     elif [[ "$1" == rmdir ]]; then
  4304.         _filedir -d
  4305.     else
  4306.         _filedir
  4307.     fi
  4308. }
  4309. # makeinfo and texi2dvi are defined elsewhere.
  4310. for i in a2ps autoconf automake bc gprof ld nm objcopy objdump readelf strip \
  4311.      bison diff patch enscript cp df dir du ln ls mkfifo mknod mv rm \
  4312.      touch vdir awk gperf grep grub indent less m4 sed shar date \
  4313.      tee who texindex cat csplit cut expand fmt fold head \
  4314.      md5sum nl od paste pr ptx sha1sum sort split tac tail tr unexpand \
  4315.      uniq wc ldd bash id irb mkdir rmdir; do
  4316.   have $i && complete -F _longopt $filenames $i
  4317. done
  4318.  
  4319. # These commands use filenames, so '-o filenames' is not needed.
  4320. for i in env netstat seq uname units wget; do
  4321.   have $i && complete -F _longopt $default $i
  4322. done
  4323. unset i
  4324.  
  4325. # gcc(1) completion
  4326. #
  4327. # The only unusual feature is that we don't parse "gcc --help -v" output
  4328. # directly, because that would include the options of all the other backend
  4329. # tools (linker, assembler, preprocessor, etc) without any indication that
  4330. # you cannot feed such options to the gcc driver directly.  (For example, the
  4331. # linker takes a -z option, but you must type -Wl,-z for gcc.)  Instead, we
  4332. # ask the driver ("g++") for the name of the compiler ("cc1"), and parse the
  4333. # --help output of the compiler.
  4334. #
  4335. have gcc &&
  4336. _gcc()
  4337. {
  4338.     local cur cc backend
  4339.  
  4340.     COMPREPLY=()
  4341.     cur=`_get_cword`
  4342.  
  4343.     _expand || return 0
  4344.  
  4345.     case "$1" in
  4346.     gcj)
  4347.         backend=jc1
  4348.         ;;
  4349.     gpc)
  4350.         backend=gpc1
  4351.         ;;
  4352.     *77)
  4353.         backend=f771
  4354.         ;;
  4355.     *)
  4356.         backend=cc1    # (near-)universal backend
  4357.         ;;
  4358.     esac
  4359.  
  4360.     if [[ "$cur" == -* ]]; then
  4361.         cc=$( $1 -print-prog-name=$backend )
  4362.         # sink stderr:
  4363.         # for C/C++/ObjectiveC it's useless
  4364.         # for FORTRAN/Java it's an error
  4365.         COMPREPLY=( $( $cc --help 2>/dev/null | tr '\t' ' ' | \
  4366.                    sed -e '/^  *-/!d' -e 's/ *-\([^ ]*\).*/-\1/' | \
  4367.                    command grep "^$cur" | sort -u ) )
  4368.     else
  4369.         _filedir
  4370.     fi
  4371. } &&
  4372. complete $filenames -F _gcc gcc g++ c++ g77 gcj gpc
  4373. [ $USERLAND = GNU -o $UNAME = Cygwin ] && \
  4374. [ -n "${have:-}" ] && complete $filenames -F _gcc cc
  4375.  
  4376. # Linux cardctl(8) completion
  4377. #
  4378. have cardctl &&
  4379. _cardctl()
  4380. {
  4381.     local cur
  4382.  
  4383.     COMPREPLY=()
  4384.     cur=`_get_cword`
  4385.  
  4386.     if [ $COMP_CWORD -eq 1 ]; then
  4387.         COMPREPLY=( $( compgen -W 'status config ident suspend \
  4388.                        resume reset eject insert scheme' \
  4389.                    -- $cur ) )
  4390.     fi
  4391. } &&
  4392. complete -F _cardctl cardctl
  4393.  
  4394. # This function is required by _dpkg() and _dpkg-reconfigure()
  4395. #
  4396. # TODO: Ubuntu (and Debian) folks removed the "have grep-status" part. In my Debian I got it,
  4397. #       and I believe it's ok if we leave it like it is now. Was that removed because
  4398. #       of Ubuntu's (and Debian's? :() inner weirdness? :) -- David (hanska-guest)
  4399. have dpkg && {
  4400. #have grep-status && {
  4401. #_comp_dpkg_installed_packages()
  4402. #{
  4403. #    grep-status -P -e "^$1" -a -FStatus 'install ok installed' -n -s Package
  4404. #}
  4405. #} || {
  4406. _comp_dpkg_installed_packages()
  4407. {
  4408.     grep -A 1 "Package: $1" /var/lib/dpkg/status | \
  4409.         grep -B 1 -Ee "ok installed|half-installed|unpacked| \
  4410.                     half-configured|config-files" \
  4411.                   -Ee "^Essential: yes" | \
  4412.         grep "Package: $1" | cut -d\  -f2
  4413. }
  4414. #}
  4415.  
  4416. # Debian dpkg(8) completion
  4417. #
  4418. _dpkg()
  4419. {
  4420.     local cur prev i
  4421.  
  4422.     COMPREPLY=()
  4423.     cur=`_get_cword`
  4424.     prev=${COMP_WORDS[COMP_CWORD-1]}
  4425.     i=$COMP_CWORD
  4426.  
  4427.     _expand || return 0
  4428.  
  4429.     # find the last option flag
  4430.     if [[ $cur != -* ]]; then
  4431.         while [[ $prev != -* && $i != 1 ]]; do
  4432.             i=$((i-1))
  4433.             prev=${COMP_WORDS[i-1]}
  4434.         done
  4435.     fi
  4436.  
  4437.     case "$prev" in
  4438.     -@(c|i|A|I|f|e|x|X|-@(install|unpack|record-avail|contents|info|fsys-tarfile|field|control|extract)))
  4439.         _filedir '?(u)deb'
  4440.         return 0
  4441.         ;;
  4442.     -@(b|-build))
  4443.         _filedir -d
  4444.         return 0
  4445.         ;;
  4446.        -@(s|p|l|-@(status|print-avail|list)))
  4447.         COMPREPLY=( $( apt-cache pkgnames $cur 2>/dev/null ) )
  4448.         return 0
  4449.         ;;
  4450.     -@(S|-search))
  4451.         _filedir
  4452.         return 0
  4453.         ;;
  4454.     -@(r|L|P|-@(remove|purge|listfiles)))
  4455.         COMPREPLY=( $( _comp_dpkg_installed_packages $cur ) )
  4456.         return 0
  4457.         ;;
  4458.     *)
  4459.  
  4460.     COMPREPLY=( $( compgen -W '-i --install --unpack -A --record-avail \
  4461.             --configure -r --remove -P --purge --get-selections \
  4462.             --set-selections --update-avail --merge-avail \
  4463.             --clear-avail  --command-fd --forget-old-unavail -s \
  4464.             --status -p --print-avail -L --listfiles -l --list \
  4465.             -S --search -C --audit --print-architecture \
  4466.             --print-gnu-build-architecture \
  4467.             --print-installation-architecture \
  4468.             --compare-versions --help --version --force-help \
  4469.             --force-all --force-auto-select --force-downgrade \
  4470.             --force-configure-any --force-hold --force-bad-path \
  4471.             --force-not-root --force-overwrite \
  4472.             --force-overwrite-diverted --force-bad-verify \
  4473.             --force-depends-version --force-depends \
  4474.             --force-confnew --force-confold --force-confdef \
  4475.             --force-confmiss --force-conflicts --force-architecture\
  4476.             --force-overwrite-dir --force-remove-reinstreq \
  4477.             --force-remove-essential -Dh \
  4478.             --debug=help --licence --admindir= --root= --instdir= \
  4479.             -O --selected-only -E --skip-same-version \
  4480.             -G --refuse-downgrade -B --auto-deconfigure \
  4481.             --no-debsig --no-act -D --debug= --status-fd \
  4482.             -b --build -I --info -f --field -c --contents \
  4483.             -x --extract -X --vextract --fsys-tarfile -e --control \
  4484.             --ignore-depends= --abort-after' -- $cur ) )
  4485.         ;;
  4486.     esac
  4487.  
  4488.  
  4489. }
  4490. complete -F _dpkg $filenames dpkg dpkg-deb
  4491. }
  4492.  
  4493. # Debian GNU dpkg-reconfigure(8) completion
  4494. #
  4495. have dpkg-reconfigure &&
  4496. _dpkg_reconfigure()
  4497. {
  4498.     local cur prev opt
  4499.  
  4500.     COMPREPLY=()
  4501.     cur=`_get_cword`
  4502.     prev=${COMP_WORDS[COMP_CWORD-1]}
  4503.  
  4504.  
  4505.     case "$prev" in
  4506.         -@(f|-frontend))
  4507.         opt=( $( echo /usr/share/perl5/Debconf/FrontEnd/* ) )
  4508.         opt=( ${opt[@]##*/} )
  4509.         opt=( ${opt[@]%.pm} )
  4510.         COMPREPLY=( $( compgen -W '${opt[@]}' -- $cur ) )
  4511.         return 0
  4512.         ;;
  4513.         -@(p|-priority))
  4514.           COMPREPLY=( $( compgen -W 'low medium high critical' -- $cur ) )
  4515.         return 0
  4516.         ;;
  4517.     esac
  4518.  
  4519.     if [[ "$cur" == -* ]]; then
  4520.         COMPREPLY=( $( compgen -W '-f --frontend -p --priority -a --all \
  4521.                        -u --unseen-only -h --help -s --showold \
  4522.                        --force --terse' -- $cur ) )
  4523.     else
  4524.         COMPREPLY=( $( _comp_dpkg_installed_packages $cur ) )
  4525.     fi
  4526. } &&
  4527. complete -F _dpkg_reconfigure $default dpkg-reconfigure
  4528.  
  4529. # Debian dpkg-source completion
  4530. #
  4531. have dpkg-source &&
  4532. _dpkg_source()
  4533. {
  4534.     local cur prev options work i action packopts unpackopts
  4535.  
  4536.     packopts="-c -l -F -V -T -D -U -W -E -sa -i -I -sk -sp -su -sr -ss -sn -sA -sK -sP -sU -sR"
  4537.     unpackopts="-sp -sn -su"
  4538.     options=`echo "-x -b $packopts $unpackopts" | xargs echo | sort -u | xargs echo`
  4539.  
  4540.     COMPREPLY=()
  4541.     if [ "$1" != "dpkg-source" ]; then
  4542.         return 1
  4543.     fi
  4544.     cur=`_get_cword`
  4545.     prev=${COMP_WORDS[COMP_CWORD-1]}
  4546.     action="options"
  4547.     for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
  4548.         if [[ ${COMP_WORDS[$i]} == "-x" ]]; then
  4549.             action=unpack
  4550.         elif [[ ${COMP_WORDS[$i]} == "-b" ]]; then
  4551.             action=pack
  4552.         elif [[ ${COMP_WORDS[$i]} == "-h" ]]; then
  4553.             action=help
  4554.         fi
  4555.     done
  4556.     # if currently seeing a complete option, return just itself.
  4557.     for i in $options; do
  4558.         if [ "$cur" = "$i" ]; then
  4559.             COMPREPLY=( "$cur" )
  4560.             return 0
  4561.         fi
  4562.     done
  4563.     case "$action" in
  4564.         "unpack")
  4565.             if [ "$cur" = "-" -o "$cur" = "-s" ]; then
  4566.                 COMPREPLY=( $unpackopts )
  4567.                 return 0
  4568.             fi
  4569.             case "$prev" in
  4570.                 "-x")
  4571.                     COMPREPLY=( $( compgen -d -- "$cur" ) \
  4572.                             $( compgen -f -X '!*.dsc' -- "$cur" ) )
  4573.                     return 0
  4574.                     ;;
  4575.                 *)
  4576.                     COMPREPLY=( $unpackopts $(compgen -d -f -- "$cur" ) )
  4577.                     return 0
  4578.                     ;;
  4579.             esac
  4580.             return 0
  4581.             ;;
  4582.         "pack")
  4583.             if [ "$cur" = "-" ]; then
  4584.                 COMPREPLY=( $packopts )
  4585.                 return 0
  4586.             fi
  4587.             if [ "$cur" = "-s" ]; then
  4588.                 COMPREPLY=( "-sa" "-sk" "-sp" "-su" "-sr" "-ss" "-sn" \
  4589.                         "-sA" "-sK" "-sP" "-sU" "-sR" )
  4590.                 return 0
  4591.             fi
  4592.             case "$prev" in
  4593.                 "-b")
  4594.                     COMPREPLY=( $( compgen -d -- "$cur" ) )
  4595.                     return 0
  4596.                     ;;
  4597.                 "-c"|"-l"|"-T"|"-i"|"-I")
  4598.                     # -c: get controlfile
  4599.                     # -l: get per-version info from this file
  4600.                     # -T: read variables here, not debian/substvars
  4601.                     # -i: <regexp> filter out files to ignore diffs of.
  4602.                     # -I: filter out files when building tarballs.
  4603.                     # return directory names and file names
  4604.                     COMPREPLY=( $( compgen -d -f ) )
  4605.                     return 0
  4606.                     ;;
  4607.                 "-F")
  4608.                     # -F: force change log format
  4609.                     COMPREPLY=( $( ( cd /usr/lib/dpkg/parsechangelog; compgen -f "$cur" ) ) )
  4610.                     return 0
  4611.                     ;;
  4612.                 "-V"|"-D")
  4613.                     # -V: set a substitution variable
  4614.                     # we don't know anything about possible variables or values
  4615.                     # so we don't try to suggest any completion.
  4616.                     COMPREPLY=()
  4617.                     return 0
  4618.                     ;;
  4619.                 "-D")
  4620.                     # -D: override or add a .dsc field and value
  4621.                     # if $cur doesn't contain a = yet, suggest variable names
  4622.                     if echo -- "$cur" | grep -q "="; then
  4623.                         # $cur contains a "="
  4624.                         COMPREPLY=()
  4625.                         return 0
  4626.                     else
  4627.                         COMPREPLY=( Format Source Version Binary Maintainer Uploader Architecture Standards-Version Build-Depends Files )
  4628.                         return 0
  4629.                     fi
  4630.                     ;;
  4631.                 "-U")
  4632.                     # -U: remove a field
  4633.                     # Suggest possible fieldnames
  4634.                     COMPREPLY=( Format Source Version Binary Maintainer Uploader Architecture Standards-Version Build-Depends Files )
  4635.                     return 0
  4636.                     ;;
  4637.                 *)
  4638.                     COMPREPLY=( $packopts )
  4639.                     return 0
  4640.                     ;;
  4641.             esac
  4642.             return 0
  4643.             ;;
  4644.         *)
  4645.             # if seeing a partial option, return possible completions.
  4646.             if [ "$cur" = "-s" ]; then
  4647.                 COMPREPLY=( "-sa" "-sk" "-sp" "-su" "-sr" "-ss" "-sn" \
  4648.                         "-sA" "-sK" "-sP" "-sU" "-sR" )
  4649.                 return 0
  4650.             fi
  4651.             # else return all possible options.
  4652.             COMPREPLY=( $options )
  4653.             return 0
  4654.             ;;
  4655.     esac
  4656. } &&
  4657. complete -F _dpkg_source dpkg-source
  4658.  
  4659. # Debian Linux dselect(8) completion.
  4660. #
  4661. have dselect &&
  4662. _dselect()
  4663. {
  4664.     local cur prev
  4665.  
  4666.     COMPREPLY=()
  4667.     cur=`_get_cword`
  4668.     prev=${COMP_WORDS[COMP_CWORD-1]}
  4669.  
  4670.     case "$prev" in
  4671.          --admindir)
  4672.           _filedir -d
  4673.           return 0
  4674.           ;;
  4675.  
  4676.          -@(D|debug))
  4677.           _filedir
  4678.           return 0
  4679.           ;;
  4680.     esac
  4681.  
  4682.     if [[ "$cur" == -* ]]; then
  4683.         COMPREPLY=( $( compgen -W '--admindir --help --version --licence \
  4684.                   --license --expert --debug' -- $cur ) )
  4685.     else
  4686.         COMPREPLY=( $( compgen -W 'access update select install config \
  4687.                   remove quit' -- $cur ) )
  4688.     fi
  4689.  
  4690.  
  4691.     return 0
  4692. } &&
  4693. complete -F _dselect $filenames dselect
  4694.  
  4695. # Java completion
  4696. #
  4697.  
  4698. # available path elements completion
  4699. have java && {
  4700. _java_path()
  4701. {
  4702.     cur=${cur##*:}
  4703.     _filedir '@(jar|zip)'
  4704. }
  4705.  
  4706. # exact classpath determination
  4707. _java_find_classpath()
  4708. {
  4709.     local i
  4710.  
  4711.     # search first in current options
  4712.     for (( i=1; i < COMP_CWORD; i++ )); do
  4713.         if [[ "${COMP_WORDS[i]}" == -@(cp|classpath) ]]; then
  4714.             classpath=${COMP_WORDS[i+1]}
  4715.             break
  4716.         fi
  4717.     done
  4718.  
  4719.     # default to environment
  4720.     [ -z "$classpath" ] && classpath=$CLASSPATH
  4721.  
  4722.     # default to current directory
  4723.     [ -z "$classpath" ] && classpath=.
  4724. }
  4725.  
  4726. # exact sourcepath determination
  4727. _java_find_sourcepath()
  4728. {
  4729.     local i
  4730.  
  4731.     # search first in current options
  4732.     for (( i=1; i < COMP_CWORD; i++ )); do
  4733.         if [[ "${COMP_WORDS[i]}" == -sourcepath ]]; then
  4734.             sourcepath=${COMP_WORDS[i+1]}
  4735.             break
  4736.         fi
  4737.     done
  4738.  
  4739.     # default to classpath
  4740.     if [ -z "$sourcepath" ]; then
  4741.         _java_find_classpath
  4742.         sourcepath=$classpath
  4743.     fi
  4744. }
  4745.  
  4746. # available classes completion
  4747. _java_classes()
  4748. {
  4749.     local classpath i
  4750.  
  4751.     # find which classpath to use
  4752.     _java_find_classpath
  4753.  
  4754.     # convert package syntax to path syntax
  4755.     cur=${cur//.//}
  4756.     # parse each classpath element for classes
  4757.     for i in ${classpath//:/ }; do
  4758.         if [ -r $i ] && [[ "$i" == *.@(jar|zip) ]]; then
  4759.             if type zipinfo &> /dev/null; then
  4760.                 COMPREPLY=( "${COMPREPLY[@]}" $( zipinfo -1 \
  4761.                 "$i" | grep "^$cur" | grep '\.class$' | \
  4762.                 grep -v "\\$" ) )
  4763.             else
  4764.                 COMPREPLY=( "${COMPREPLY[@]}" $( jar tf "$i" \
  4765.                 "$cur" | grep "\.class$" | grep -v "\\$" ) )
  4766.             fi
  4767.  
  4768.         elif [ -d $i ]; then
  4769.             i=${i%/}
  4770.             
  4771.             # See bug #496828
  4772.             COMPREPLY=( "${COMPREPLY[@]}" $( find "$i" -type f \
  4773.             -maxdepth 1 -path "$i/$cur*.class" 2>/dev/null | \
  4774.             grep -v "\\$" | sed -e "s|^$i/||" ) )
  4775.             
  4776.             # FIXME: if we have foo.class and foo/, the completion
  4777.             # returns "foo/"... how to give precedence to files
  4778.             # over directories?
  4779.         fi
  4780.     done
  4781.  
  4782.     # remove class extension
  4783.     COMPREPLY=( ${COMPREPLY[@]%.class} )
  4784.     # convert path syntax to package syntax
  4785.     COMPREPLY=( ${COMPREPLY[@]//\//.} )
  4786. }
  4787.  
  4788. # available packages completion
  4789. _java_packages()
  4790. {
  4791.     local sourcepath i
  4792.  
  4793.     # find which sourcepath to use
  4794.     _java_find_sourcepath
  4795.  
  4796.     # convert package syntax to path syntax
  4797.     cur=${cur//.//}
  4798.     # parse each sourcepath element for packages
  4799.     for i in ${sourcepath//:/ }; do
  4800.         if [ -d $i ]; then
  4801.             COMPREPLY=( "${COMPREPLY[@]}" $( command ls -F -d \
  4802.                 $i/$cur* 2>/dev/null | sed -e 's|^'$i'/||' ) )
  4803.         fi
  4804.     done
  4805.     # keep only packages
  4806.     COMPREPLY=( $( echo "${COMPREPLY[@]}" | tr " " "\n" | grep "/$" ) )
  4807.     # remove packages extension
  4808.     COMPREPLY=( ${COMPREPLY[@]%/} )
  4809.     # convert path syntax to package syntax
  4810.     cur=${COMPREPLY[@]//\//.}
  4811. }
  4812.  
  4813. # java completion
  4814. #
  4815. _java()
  4816. {
  4817.     local cur prev i
  4818.  
  4819.     COMPREPLY=()
  4820.     cur=`_get_cword`
  4821.     prev=${COMP_WORDS[COMP_CWORD-1]}
  4822.  
  4823.     for ((i=1; i < $COMP_CWORD; i++)); do
  4824.         case ${COMP_WORDS[$i]} in
  4825.             -cp|-classpath)
  4826.             ((i++))    # skip the classpath string.
  4827.             ;;
  4828.             -*)
  4829.             # this is an option, not a class/jarfile name.
  4830.             ;;
  4831.             *)
  4832.             # once we've seen a class, just do filename completion
  4833.             _filedir
  4834.             return 0
  4835.             ;;
  4836.         esac
  4837.     done
  4838.  
  4839.     case $prev in
  4840.         -@(cp|classpath))
  4841.             _java_path
  4842.             return 0
  4843.             ;;
  4844.     esac
  4845.  
  4846.     if [[ "$cur" == -* ]]; then
  4847.         # relevant options completion
  4848.         COMPREPLY=( $( compgen -W '-client -hotspot -server -classic \
  4849.                 -cp -classpath -D -verbose -verbose:class \
  4850.                 -verbose:gc -version:jni -version \
  4851.                 -showversion -? -help -X -jar \
  4852.                 -ea -enableassertions -da -disableassertions \
  4853.                 -esa -enablesystemassertions \
  4854.                 -dsa -disablesystemassertions ' -- $cur ) )
  4855.     else
  4856.         if [[ "$prev" == -jar ]]; then
  4857.             # jar file completion
  4858.             _filedir jar
  4859.         else
  4860.             # classes completion
  4861.             _java_classes
  4862.         fi
  4863.     fi
  4864. }
  4865. complete -F _java $filenames java
  4866. }
  4867.  
  4868. # javadoc completion
  4869. #
  4870. have javadoc &&
  4871. _javadoc()
  4872. {
  4873.     COMPREPLY=()
  4874.     local cur prev
  4875.  
  4876.     cur=`_get_cword`
  4877.     prev=${COMP_WORDS[COMP_CWORD-1]}
  4878.  
  4879.     case $prev in
  4880.         -@(overview|helpfile|stylesheetfile))
  4881.             _filedir
  4882.             return 0
  4883.             ;;
  4884.         -d)
  4885.             _filedir -d
  4886.             return 0
  4887.             ;;
  4888.         -@(classpath|bootclasspath|docletpath|sourcepath|extdirs))
  4889.             _java_path
  4890.             return 0
  4891.             ;;
  4892.     esac
  4893.  
  4894.     if [[ "$cur" == -* ]]; then
  4895.         # relevant options completion
  4896.         COMPREPLY=( $( compgen -W '-overview -public -protected \
  4897.                 -package -private -help -doclet -docletpath \
  4898.                 -sourcepath -classpath -exclude -subpackages \
  4899.                 -breakiterator -bootclasspath -source -extdirs \
  4900.                 -verbose -locale -encoding -J -d -use -version \
  4901.                 -author -docfilessubdirs -splitindex \
  4902.                 -windowtitle -doctitle -header -footer -bottom \
  4903.                 -link -linkoffline -excludedocfilessubdir \
  4904.                 -group -nocomment -nodeprecated -noqualifier \
  4905.                 -nosince -nodeprecatedlist -notree -noindex \
  4906.                 -nohelp -nonavbar -quiet -serialwarn -tag \
  4907.                 -taglet -tagletpath -charset -helpfile \
  4908.                 -linksource -stylesheetfile -docencoding' -- \
  4909.                 $cur ) )
  4910.     else
  4911.         # source files completion
  4912.         _filedir java
  4913.         # packages completion
  4914.         _java_packages
  4915.     fi
  4916. } &&
  4917. complete -F _javadoc $filenames javadoc
  4918.  
  4919. # javac completion
  4920. #
  4921. have javac &&
  4922. _javac()
  4923. {
  4924.     COMPREPLY=()
  4925.     local cur prev
  4926.  
  4927.     cur=`_get_cword`
  4928.     prev=${COMP_WORDS[COMP_CWORD-1]}
  4929.  
  4930.     case $prev in
  4931.         -d)
  4932.             _filedir -d
  4933.             return 0
  4934.             ;;
  4935.         -@(classpath|bootclasspath|sourcepath|extdirs))
  4936.             _java_path
  4937.             return 0
  4938.             ;;
  4939.     esac
  4940.  
  4941.     if [[ "$cur" == -* ]]; then
  4942.         # relevant options completion
  4943.         COMPREPLY=( $( compgen -W '-g -g:none -g:lines -g:vars\
  4944.         -g:source -O -nowarn -verbose -deprecation -classpath\
  4945.         -sourcepath -bootclasspath -extdirs -d -encoding -source\
  4946.         -target -help' -- $cur ) )
  4947.     else
  4948.         # source files completion
  4949.         _filedir java
  4950.     fi
  4951. } &&
  4952. complete -F _javac $filenames javac
  4953.  
  4954. # PINE address-book completion
  4955. #
  4956. have pine &&
  4957. _pineaddr()
  4958. {
  4959.     local cur
  4960.  
  4961.     COMPREPLY=()
  4962.     cur=`_get_cword`
  4963.  
  4964.     COMPREPLY=( $( compgen -W '$( awk "{print \$1}" ~/.addressbook 2>/dev/null)' \
  4965.             -- $cur ) )
  4966. } &&
  4967. complete -F _pineaddr $default pine
  4968.  
  4969. # mutt completion
  4970. #
  4971. # Mutt doesn't have an "addressbook" like Pine, but it has aliases and
  4972. # a "query" function to retrieve addresses, so that's what we use here.
  4973. have mutt || have muttng && {
  4974. _muttaddr()
  4975. {
  4976.     _muttaliases
  4977.     _muttquery
  4978.  
  4979.     cur=`_get_cword`
  4980.     COMPREPLY=( "${COMPREPLY[@]}" $( compgen -u -- $cur ) )
  4981.  
  4982.     return 0
  4983. }
  4984.  
  4985. _muttconffiles()
  4986. {
  4987.     local file sofar
  4988.     local -a newconffiles
  4989.  
  4990.     sofar=" $1 "
  4991.     shift
  4992.     while [[ "$1" ]]; do
  4993.         newconffiles=( $(sed -rn 's|^source[[:space:]]+([^[:space:]]+).*$|\1|p' $(eval echo $1) ) )
  4994.         for file in "${newconffiles[@]}"; do
  4995.         [[ ! "$file" ]] || [[ "${sofar/ ${file} / }" != "$sofar" ]] &&
  4996.             continue
  4997.         sofar="$sofar $file"
  4998.         sofar=" $(eval _muttconffiles \"$sofar\" $file) "
  4999.         done
  5000.         shift
  5001.     done
  5002.     echo $sofar
  5003. }
  5004.  
  5005. _muttaliases()
  5006. {
  5007.     local cur muttrc
  5008.     local -a conffiles aliases
  5009.     cur=`_get_cword =`
  5010.  
  5011.     [ -f ~/.${muttcmd}/${muttcmd}rc ] && muttrc="~/.${muttcmd}/${muttcmd}rc"
  5012.     [ -f ~/.${muttcmd}rc ] && muttrc="~/.${muttcmd}rc"
  5013.     [ -z "$muttrc" ] && return 0
  5014.  
  5015.     conffiles=( $(eval _muttconffiles $muttrc $muttrc) )
  5016.     aliases=( $( sed -rn 's|^alias[[:space:]]+([^[:space:]]+).*$|\1|p' \
  5017.             $(eval echo "${conffiles[@]}") ) )
  5018.     COMPREPLY=( "${COMPREPLY[@]}" $( compgen -W "${aliases[*]}" -- $cur ) )
  5019.  
  5020.     return 0
  5021. }
  5022.  
  5023. _muttquery()
  5024. {
  5025.     local cur querycmd
  5026.     local -a queryresults
  5027.     cur=`_get_cword`
  5028.  
  5029.     querycmd="$( $muttcmd -Q query_command  | sed -r 's|^query_command=\"(.*)\"$|\1|; s|%s|'$cur'|' )"
  5030.     if [ -z "$cur" -o -z "$querycmd" ]; then
  5031.         queryresults=()
  5032.     else
  5033.         queryresults=( $( $querycmd | \
  5034.           sed -nr '2,$s|^([^[:space:]]+).*|\1|p' ) )
  5035.     fi
  5036.  
  5037.     COMPREPLY=( "${COMPREPLY[@]}" $( compgen -W "${queryresults[*]}" \
  5038.             -- $cur ) )
  5039.  
  5040.     return 0
  5041. }
  5042.  
  5043. _muttfiledir()
  5044. {
  5045.     local cur folder spoolfile
  5046.     cur=`_get_cword`
  5047.  
  5048.     # This is currently not working so well. Perhaps this function should
  5049.     # just call _filedir() for the moment.
  5050.     if [[ $cur == [=+]* ]]; then
  5051.         folder="$( $muttcmd -Q folder | sed -r 's|^folder=\"(.*)\"$|\1|' )"
  5052.         : folder:=~/Mail
  5053.  
  5054.         # Match any file in $folder beginning with $cur
  5055.         # (minus the leading '=' sign).
  5056.         COMPREPLY=( $( compgen -f -- "$folder/${cur:1}" ) )
  5057.         COMPREPLY=( ${COMPREPLY[@]#$folder/} )
  5058.         return 0
  5059.     elif [ "$cur" == !* ]; then
  5060.         spoolfile="$( $muttcmd -Q spoolfile | sed -r 's|^spoolfile=\"(.*)\"$|\1|' )"
  5061.         [ ! -z "$spoolfile" ] && eval cur="${cur/^!/$spoolfile}";
  5062.     fi
  5063.     _filedir
  5064.  
  5065.     return 0
  5066. }
  5067.  
  5068. _mutt()
  5069. {
  5070.     local cur prev
  5071.     cur=`_get_cword`
  5072.     prev=${COMP_WORDS[COMP_CWORD-1]}
  5073.  
  5074.     COMPREPLY=()
  5075.  
  5076.     [ ${COMP_WORDS[0]} == muttng ] && muttcmd="muttng" || muttcmd="mutt"
  5077.  
  5078.     case "$cur" in
  5079.     -*)
  5080.         COMPREPLY=( $( compgen -W '-A -a -b -c -e -f -F -H -i -m -n \
  5081.                         -p -Q -R -s -v -x -y -z -Z -h' \
  5082.                         -- $cur ) )
  5083.         return 0
  5084.         ;;
  5085.     *)
  5086.         case "$prev" in
  5087.         -@(a|f|F|H|i))
  5088.             _muttfiledir
  5089.             return 0
  5090.             ;;
  5091.         -A)
  5092.             _muttaliases
  5093.             return 0
  5094.             ;;
  5095.         -@(e|m|Q|s|h|p|R|v|y|z|Z))
  5096.             return 0
  5097.             ;;
  5098.         *)
  5099.             _muttaddr
  5100.             return 0
  5101.             ;;
  5102.         esac
  5103.         ;;
  5104.     esac
  5105.  
  5106. }
  5107. complete -F _mutt $default $filenames mutt muttng
  5108. }
  5109.  
  5110. _configure_func()
  5111. {
  5112.     local cur
  5113.  
  5114.     COMPREPLY=()
  5115.     cur=`_get_cword`
  5116.  
  5117.     # if $COMP_CONFIGURE_HINTS is not null, then completions of the form
  5118.     # --option=SETTING will include 'SETTING' as a contextual hint
  5119.     [[ "$cur" != -* ]] && return 0
  5120.  
  5121.     if [ -n "$COMP_CONFIGURE_HINTS" ]; then
  5122.         COMPREPLY=( $( $1 --help 2>&1 | awk '/^  --[A-Za-z]/ { print $1; if ($2 ~ /--[A-Za-z]/) print $2 }' | sed -e 's/[[,].*//g' | grep ^$cur ) )
  5123.     else
  5124.         COMPREPLY=( $( $1 --help 2>&1 | awk '/^  --[A-Za-z]/ { print $1; if ($2 ~ /--[A-Za-z]/) print $2 }' | sed -e 's/[[,=].*//g' | grep ^$cur ) )
  5125.     fi
  5126. }
  5127. complete -F _configure_func $default configure
  5128.  
  5129. # Debian reportbug(1) completion
  5130. #
  5131. have reportbug &&
  5132. _reportbug()
  5133. {
  5134.     local cur prev
  5135.  
  5136.     COMPREPLY=()
  5137.     cur=`_get_cword`
  5138.     prev=${COMP_WORDS[COMP_CWORD-1]}
  5139.  
  5140.     case "$prev" in
  5141.         -f|--filename|-i|--include|--mta|-o|--output)
  5142.         _filedir
  5143.         return 0
  5144.         ;;
  5145.         -B|--bts)
  5146.         COMPREPLY=( $( compgen -W "debian guug kde mandrake help" -- \
  5147.                    $cur ))
  5148.         return 0
  5149.         ;;
  5150.         -e|--editor|--mua)
  5151.         COMP_WORDS=(COMP_WORDS[0] $cur)
  5152.         COMP_CWORD=1
  5153.         _command
  5154.         return 0
  5155.         ;;
  5156.         --mode)
  5157.         COMPREPLY=( $( compgen -W "novice standard expert" -- $cur ) )
  5158.         return 0
  5159.         ;;
  5160.         -S|--severity)
  5161.         COMPREPLY=( $( compgen -W "grave serious important normal \
  5162.                        minor wishlist" -- $cur ) )
  5163.         return 0
  5164.         ;;
  5165.         -u|--ui|--interface)
  5166.         COMPREPLY=( $( compgen -W "newt text gnome" -- $cur ) )
  5167.         return 0
  5168.         ;;
  5169.         -t|--type)
  5170.         COMPREPLY=( $( compgen -W "gnats debbugs" -- $cur ) )
  5171.         return 0
  5172.         ;;
  5173.         -T|--tags)
  5174.         COMPREPLY=( $( compgen -W "none \
  5175.                        woody potato sarge sarge-ignore etch etch-ignore \
  5176.                        lenny lenny-ignore sid experimental confirmed \
  5177.                        d-i fixed fixed-in-experimental fixed-upstream \
  5178.                        help l10n moreinfo patch pending security \
  5179.                        unreproducible upstream wontfix ipv6 lfs" -- $cur ))
  5180.         return 0
  5181.         ;;
  5182.         *)
  5183.         ;;
  5184.     esac
  5185.  
  5186.     COMPREPLY=($( compgen -W '-h --help -v --version -a --af -b \
  5187.             --no-query-bts --query-bts -B --bts -c --configure \
  5188.             --no-config-files --check-available -d --debug \
  5189.             --no-check-available -e --editor --email -f \
  5190.             --filename -g --gnupg -H --header -i --include -j \
  5191.             --justification -l --ldap --no-ldap -L --list-cc -m \
  5192.             --maintonly --mode --mua --mta --mutt -n --mh --nmh \
  5193.             -o --output -p --print -P --pgp --proxy --http_proxy\
  5194.             -q --quiet -Q --query-only --realname --report-quiet \
  5195.             --reply-to --replyto -s --subject -S --severity \
  5196.             --smtphost -t --type -T --tags --template -V -x \
  5197.             --no-cc --package-version -z --no-compress \
  5198.             --ui --interface -u \
  5199.             wnpp boot-floppies kernel bugs.debian.org \
  5200.             cdimage.debian.org general installation-reports \
  5201.             listarchives lists.debian.org mirrors nm.debian.org \
  5202.             press project qa.debian.org release-notes \
  5203.             security.debian.org tech-ctte upgrade-reports \
  5204.             www.debian.org' -- $cur ) \
  5205.                 $( apt-cache pkgnames -- $cur 2> /dev/null) )
  5206.     _filedir
  5207.     return 0
  5208. } &&
  5209. complete -F _reportbug $filenames reportbug
  5210.  
  5211. # Debian querybts(1) completion
  5212. #
  5213. have querybts &&
  5214. _querybts()
  5215. {
  5216.     local cur prev
  5217.  
  5218.     COMPREPLY=()
  5219.     cur=`_get_cword`
  5220.     prev=${COMP_WORDS[COMP_CWORD-1]}
  5221.  
  5222.     case "$prev" in
  5223.         -B|--bts)
  5224.         COMPREPLY=( $( compgen -W "debian guug kde mandrake help" -- \
  5225.                    $cur ))
  5226.         return 0
  5227.         ;;
  5228.         -u|--ui|--interface)
  5229.         COMPREPLY=($( compgen -W "newt text gnome" -- $cur ))
  5230.         return 0
  5231.         ;;
  5232.         *)
  5233.         ;;
  5234.     esac
  5235.  
  5236.     COMPREPLY=($( compgen -W '-h --help -v --version -A --archive \
  5237.             -B --bts -l --ldap --no-ldap --proxy= --http_proxy= \
  5238.             -s --source -w --web -u --ui --interface \
  5239.             wnpp boot-floppies kernel bugs.debian.org \
  5240.             cdimage.debian.org general installation-reports \
  5241.             listarchives lists.debian.org mirrors nm.debian.org \
  5242.             press project qa.debian.org release-notes \
  5243.             security.debian.org tech-ctte upgrade-reports \
  5244.             www.debian.org' -- $cur ) \
  5245.                 $( apt-cache pkgnames -- $cur 2> /dev/null) )
  5246. } &&
  5247. complete -F _querybts $filenames querybts
  5248.  
  5249. # update-alternatives completion
  5250. #
  5251. have update-alternatives && {
  5252. installed_alternatives()
  5253. {
  5254.     local admindir
  5255.     # find the admin dir
  5256.     for i in alternatives dpkg/alternatives rpm/alternatives; do
  5257.         [ -d /var/lib/$i ] && admindir=/var/lib/$i && break
  5258.     done
  5259.     for (( i=1; i < COMP_CWORD; i++ )); do
  5260.         if [[ "${COMP_WORDS[i]}" == --admindir ]]; then
  5261.             admindir=${COMP_WORDS[i+1]}
  5262.             break
  5263.         fi
  5264.     done
  5265.     COMPREPLY=( $( command ls $admindir | grep "^$cur" ) )
  5266. }
  5267.  
  5268. _update_alternatives()
  5269. {
  5270.     local cur prev mode args i
  5271.  
  5272.     COMPREPLY=()
  5273.     cur=`_get_cword`
  5274.     prev=${COMP_WORDS[COMP_CWORD-1]}
  5275.  
  5276.     case "$prev" in
  5277.     --@(altdir|admindir))
  5278.         _filedir -d
  5279.         return 0
  5280.         ;;
  5281.     --@(help|version))
  5282.         return 0
  5283.         ;;
  5284.     esac
  5285.  
  5286.     # find which mode to use and how many real args used so far
  5287.     for (( i=1; i < COMP_CWORD; i++ )); do
  5288.         if [[ "${COMP_WORDS[i]}" == --@(install|remove|auto|display|config|remove-all) ]]; then
  5289.             mode=${COMP_WORDS[i]}
  5290.             args=$(($COMP_CWORD - i))
  5291.             break
  5292.         fi
  5293.     done
  5294.  
  5295.     case $mode in
  5296.     --install)
  5297.         case $args in
  5298.         1)
  5299.             _filedir
  5300.             ;;
  5301.         2)
  5302.             installed_alternatives
  5303.             ;;
  5304.         3)
  5305.             _filedir
  5306.             ;;
  5307.         esac
  5308.         ;;
  5309.     --remove)
  5310.         case $args in
  5311.         1)
  5312.             installed_alternatives
  5313.             ;;
  5314.         2)
  5315.             _filedir
  5316.             ;;
  5317.         esac
  5318.         ;;
  5319.     --auto)
  5320.         installed_alternatives
  5321.         ;;
  5322.     --remove-all)
  5323.         installed_alternatives
  5324.         ;;
  5325.     --display)
  5326.         installed_alternatives
  5327.         ;;
  5328.     --config)
  5329.         installed_alternatives
  5330.         ;;
  5331.     *)
  5332.         COMPREPLY=( $( compgen -W '--verbose --quiet --help --version \
  5333.                    --altdir --admindir' -- $cur ) \
  5334.                 $( compgen -W '--install --remove --auto --display \
  5335.                    --config' -- $cur ) )
  5336.     esac
  5337. }
  5338. complete -F _update_alternatives update-alternatives
  5339. }
  5340.  
  5341. # Python completion
  5342. #
  5343. have python &&
  5344. _python()
  5345. {
  5346.     local prev cur
  5347.  
  5348.     COMPREPLY=()
  5349.     cur=`_get_cword`
  5350.     prev=${COMP_WORDS[COMP_CWORD-1]##*/}
  5351.  
  5352.     case "$prev" in
  5353.     -Q)
  5354.         COMPREPLY=( $( compgen -W "old new warn warnall" -- $cur ) )
  5355.         return 0
  5356.         ;;
  5357.     -W)
  5358.         COMPREPLY=( $( compgen -W "ignore default all module once error" -- $cur ) )
  5359.         return 0
  5360.         ;;
  5361.     -c)
  5362.         _filedir '@(py|pyc|pyo)'
  5363.         return 0
  5364.         ;;
  5365.     !(python|-?))
  5366.         [[ ${COMP_WORDS[COMP_CWORD-2]} != -@(Q|W) ]] && _filedir
  5367.         ;;
  5368.     esac
  5369.  
  5370.  
  5371.     # if '-c' is already given, complete all kind of files.
  5372.     for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
  5373.         if [[ ${COMP_WORDS[i]} == -c ]]; then
  5374.             _filedir
  5375.         fi
  5376.     done
  5377.  
  5378.  
  5379.     if [[ "$cur" != -* ]]; then
  5380.         _filedir '@(py|pyc|pyo)'
  5381.     else
  5382.         COMPREPLY=( $( compgen -W "- -d -E -h -i -O -Q -S -t -u \
  5383.                        -U -v -V -W -x -c" -- $cur ) )
  5384.     fi
  5385.  
  5386.  
  5387.  
  5388.     return 0
  5389. } &&
  5390. complete -F _python $filenames python
  5391.  
  5392. # Perl completion
  5393. #
  5394. have perl &&
  5395. {
  5396. _perlmodules()
  5397. {
  5398.     COMPREPLY=( $( compgen -P "$prefix" -W "$( perl -e 'sub mods { my ($base,$dir)=@_; return if  $base !~ /^\Q$ENV{cur}/; chdir($dir) or return; for (glob(q[*.pm])) {s/\.pm$//; print qq[$base$_\n]}; mods(/^(?:[.\d]+|$Config{archname}-$Config{osname}|auto)$/ ? undef : qq[${base}${_}\\\\:\\\\:],qq[$dir/$_]) for grep {-d} glob(q[*]); } mods(undef,$_) for @INC;' )" -- $cur ) )
  5399. }
  5400.  
  5401. _perl()
  5402. {
  5403.     local cur prev prefix temp
  5404.     local optPrefix optSuffix
  5405.  
  5406.     COMPREPLY=()
  5407.     cur=`_get_cword`
  5408.     prev=${COMP_WORDS[COMP_CWORD-1]}
  5409.     prefix=""
  5410.  
  5411.     # If option not followed by whitespace, reassign prev and cur
  5412.     if [[ "$cur" == -?* ]]; then
  5413.     temp=$cur
  5414.     prev=${temp:0:2}
  5415.     cur=${temp:2}
  5416.     optPrefix=-P$prev
  5417.     optSuffix=-S/
  5418.     prefix=$prev
  5419.     fi
  5420.  
  5421.     # only handle module completion for now
  5422.     case "$prev" in
  5423.     -I|-x)
  5424.         local IFS=$'\t\n'
  5425.         COMPREPLY=( $( compgen -d $optPrefix $optSuffix -- "$cur" ) )
  5426.         return 0
  5427.         ;;
  5428.     -m|-M)
  5429.         _perlmodules
  5430.         return 0
  5431.         ;;
  5432.     esac
  5433.  
  5434.     if [[ "$cur" == -* ]]; then
  5435.         COMPREPLY=( $( compgen -W '-C -s -T -u -U -W -X -h -v -V -c -w -d \
  5436.             -D -p -n -a -F -l -0 -I -m -M -P -S -x -i -e ' -- $cur ) )
  5437.     else
  5438.     _filedir
  5439.     fi
  5440. }
  5441. complete -F _perl $nospace $filenames perl
  5442.  
  5443. _perldoc()
  5444. {
  5445.     local cur prev prefix temp
  5446.  
  5447.     COMPREPLY=()
  5448.     cur=`_get_cword`
  5449.     prev=${COMP_WORDS[COMP_CWORD-1]}
  5450.     prefix=""
  5451.  
  5452.     # completing an option (may or may not be separated by a space)
  5453.     if [[ "$cur" == -?* ]]; then
  5454.     temp=$cur
  5455.     prev=${temp:0:2}
  5456.     cur=${temp:2}
  5457.     prefix=$prev
  5458.     fi
  5459.  
  5460.     # complete builtin perl functions
  5461.     case $prev in
  5462.     -f)
  5463.         COMPREPLY=( $( compgen -W 'chomp chop chr crypt hex index lc \
  5464.         lcfirst length oct ord pack q qq reverse rindex sprintf \
  5465.         substr tr uc ucfirst y m pos quotemeta s split study qr abs \
  5466.         atan2 cos exp hex int log oct rand sin sqrt srand pop push \
  5467.         shift splice unshift grep join map qw reverse sort unpack \
  5468.         delete each exists keys values binmode close closedir \
  5469.         dbmclose dbmopen die eof fileno flock format getc print \
  5470.         printf read readdir rewinddir seek seekdir select syscall \
  5471.         sysread sysseek syswrite tell telldir truncate warn write \
  5472.         pack read syscall sysread syswrite unpack vec -X chdir chmod \
  5473.         chown chroot fcntl glob ioctl link lstat mkdir open opendir \
  5474.         readlink rename rmdir stat symlink umask unlink utime caller \
  5475.         continue do dump eval exit goto last next redo return \
  5476.         sub wantarray caller import local my our package use defined \
  5477.         formline reset scalar undef \
  5478.         alarm exec fork getpgrp getppid getpriority kill pipe qx \
  5479.         setpgrp setpriority sleep system times wait waitpid \
  5480.         import no package require use bless dbmclose dbmopen package \
  5481.         ref tie tied untie use accept bind connect getpeername \
  5482.         getsockname getsockopt listen recv send setsockopt shutdown \
  5483.         socket socketpair msgctl msgget msgrcv msgsnd semctl semget \
  5484.         semop shmctl shmget shmread shmwrite endgrent endhostent \
  5485.         endnetent endpwent getgrent getgrgid getgrnam getlogin \
  5486.         getpwent getpwnam getpwuid setgrent setpwent endprotoent \
  5487.         endservent gethostbyaddr gethostbyname gethostent \
  5488.         getnetbyaddr getnetbyname getnetent getprotobyname \
  5489.         getprotobynumber getprotoent getservbyname getservbyport \
  5490.         getservent sethostent setnetent setprotoent setservent \
  5491.         gmtime localtime time times' -- $cur ) )
  5492.         return 0
  5493.         ;;
  5494.     esac
  5495.  
  5496.     if [[ "$cur" == -* ]]; then
  5497.         COMPREPLY=( $( compgen -W '-h -v -t -u -m -l -F -X -f -q' -- $cur ))
  5498.     else
  5499.         # return available modules (unless it is clearly a file)
  5500.         if [[ "$cur" != */* ]]; then
  5501.             _perlmodules
  5502.             COMPREPLY=( "${COMPREPLY[@]}" $( compgen -W '$( PAGER=/bin/cat man perl |  sed -ne "/perl.*Perl overview/,/perlwin32/p" | awk "\$NF=2 { print \$1}" | grep perl )' -- $cur ) )
  5503.         fi
  5504.     fi
  5505. }
  5506. complete -F _perldoc $default perldoc
  5507. }
  5508.  
  5509. # rcs(1) completion
  5510. #
  5511. have rcs &&
  5512. _rcs()
  5513. {
  5514.     local cur prev file dir i
  5515.  
  5516.     COMPREPLY=()
  5517.     cur=`_get_cword`
  5518.     prev=${COMP_WORDS[COMP_CWORD-1]}
  5519.  
  5520.     file=${cur##*/}
  5521.     dir=${cur%/*}
  5522.  
  5523.     # deal with relative directory
  5524.     [ "$file" = "$dir" ] && dir=.
  5525.  
  5526.     COMPREPLY=( $( compgen -f "$dir/RCS/$file" ) )
  5527.  
  5528.     for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
  5529.         file=${COMPREPLY[$i]##*/}
  5530.         dir=${COMPREPLY[$i]%RCS/*}
  5531.         COMPREPLY[$i]=$dir$file
  5532.     done
  5533.  
  5534.     COMPREPLY=( "${COMPREPLY[@]}" $( compgen -G "$dir/$file*,v" ) )
  5535.  
  5536.     for (( i=0; i < ${#COMPREPLY[@]}; i++ )); do
  5537.         COMPREPLY[$i]=${COMPREPLY[$i]%,v}
  5538.     done
  5539.  
  5540.     # default to files if nothing returned and we're checking in.
  5541.     # otherwise, default to directories
  5542.     [ ${#COMPREPLY[@]} -eq 0 -a $1 = ci ] && _filedir || _filedir -d
  5543. } &&
  5544. complete -F _rcs $filenames ci co rlog rcs rcsdiff
  5545.  
  5546. # lilo(8) completion
  5547. #
  5548. have lilo && {
  5549. _lilo_labels()
  5550. {
  5551.     COMPREPLY=( $( awk -F'=' '/label/ {print $2}' \
  5552.         /etc/lilo.conf | sed -e 's/"//g' | grep "^$cur" ) )
  5553. }
  5554.  
  5555. _lilo()
  5556. {
  5557.     local cur prev
  5558.  
  5559.     COMPREPLY=()
  5560.     cur=`_get_cword`
  5561.     prev=${COMP_WORDS[COMP_CWORD-1]}
  5562.  
  5563.     case $prev in
  5564.         -@(C|i|m|s|S))
  5565.             _filedir
  5566.             return 0
  5567.             ;;
  5568.         -r)
  5569.             _filedir -d
  5570.             return 0
  5571.             ;;
  5572.         -@(I|D|R))
  5573.             # label completion
  5574.             _lilo_labels
  5575.             return 0
  5576.             ;;
  5577.         -@(A|b|M|u|U))
  5578.             # device completion
  5579.             cur=${cur:=/dev/}
  5580.             _filedir
  5581.             return 0
  5582.             ;;
  5583.         -T)
  5584.             # topic completion
  5585.             COMPREPLY=( $( compgen -W 'help ChRul EBDA geom geom= \
  5586.                     table= video' -- $cur ) )
  5587.             return 0
  5588.             ;;
  5589.     esac
  5590.  
  5591.     if [[ "$cur" == -* ]]; then
  5592.         # relevant options completion
  5593.         COMPREPLY=( $( compgen -W '-A -b -c -C -d -f -g -i -I -l -L -m \
  5594.             -M -p -P -q -r -R -s -S -t -T -u -U -v -V -w -x -z' -- \
  5595.             $cur ) )
  5596.     fi
  5597. }
  5598. complete -F _lilo lilo
  5599. }
  5600.  
  5601. # links completion
  5602. #
  5603. have links &&
  5604. _links()
  5605. {
  5606.     local cur
  5607.  
  5608.     COMPREPLY=()
  5609.     cur=`_get_cword`
  5610.  
  5611.     case "$cur" in
  5612.         --*)
  5613.         COMPREPLY=( $( compgen -W '--help' -- $cur ) )
  5614.         ;;
  5615.         -*)
  5616.         COMPREPLY=( $( compgen -W '-async-dns -max-connections \
  5617.                 -max-connections-to-host -retries \
  5618.                 -receive-timeout -unrestartable-receive-timeout\
  5619.                 -format-cache-size -memory-cache-size \
  5620.                 -http-proxy -ftp-proxy -download-dir \
  5621.                 -assume-codepage -anonymous -dump -no-connect \
  5622.                 -source -version -help' -- $cur ) )
  5623.         ;;
  5624.         *)
  5625.         if [ -r ~/.links/links.his ]; then
  5626.             COMPREPLY=( $( compgen -W '$( < ~/.links/links.his )' \
  5627.                    -- $cur ) )
  5628.         fi
  5629.                 _filedir '@(htm|html)'
  5630.                 return 0
  5631.         ;;
  5632.     esac
  5633.  
  5634.     return 0
  5635. } &&
  5636. complete -F _links $filenames links
  5637.  
  5638. [ $UNAME = FreeBSD ] && {
  5639. # FreeBSD package management tool completion
  5640. #
  5641. _pkg_delete()
  5642. {
  5643.     local cur pkgdir prev
  5644.  
  5645.     pkgdir=${PKG_DBDIR:-/var/db/pkg}/
  5646.     cur=`_get_cword`
  5647.     prev=${COMP_WORDS[COMP_CWORD-1]}
  5648.  
  5649.     [ "$prev" = "-o" -o "$prev" = "-p" -o "$prev" = "-W" ] && return 0
  5650.  
  5651.     COMPREPLY=( $( compgen -d $pkgdir$cur ) )
  5652.     COMPREPLY=( ${COMPREPLY[@]#$pkgdir} )
  5653.  
  5654.     return 0
  5655. }
  5656. complete -F _pkg_delete $dirnames pkg_delete pkg_info
  5657. have pkg_deinstall && complete -F _pkg_delete $dirnames pkg_deinstall
  5658.  
  5659. # FreeBSD kernel module commands
  5660. #
  5661. _kldload()
  5662. {
  5663.     local cur moddir
  5664.  
  5665.     moddir=/modules/
  5666.     [ -d $moddir ] || moddir=/boot/kernel/
  5667.     cur=`_get_cword`
  5668.  
  5669.     COMPREPLY=( $( compgen -f $moddir$cur ) )
  5670.     COMPREPLY=( ${COMPREPLY[@]#$moddir} )
  5671.     COMPREPLY=( ${COMPREPLY[@]%.ko} )
  5672.  
  5673.     return 0
  5674. }
  5675. complete -F _kldload $filenames kldload
  5676.  
  5677. _kldunload()
  5678. {
  5679.     local cur
  5680.     cur=`_get_cword`
  5681.     COMPREPLY=( $(kldstat | sed -ne "s/^.*[ \t]\+\($cur[a-z_]\+\).ko$/\1/p") )
  5682. }
  5683. complete -F _kldunload $filenames kldunload
  5684. }
  5685.  
  5686. # FreeBSD portupgrade completion
  5687. #
  5688. have portupgrade &&
  5689. _portupgrade()
  5690. {
  5691.     local cur pkgdir prev
  5692.  
  5693.     pkgdir=${PKG_DBDIR:-/var/db/pkg}/
  5694.     cur=`_get_cword`
  5695.     prev=${COMP_WORDS[COMP_CWORD-1]}
  5696.  
  5697.     [ "$prev" = "-l" -o "$prev" = "-L" -o "$prev" = "-o" ] && return 0
  5698.  
  5699.     COMPREPLY=( $( compgen -d $pkgdir$cur ) )
  5700.     COMPREPLY=( ${COMPREPLY[@]#$pkgdir} )
  5701.     COMPREPLY=( ${COMPREPLY[@]%-*} )
  5702.  
  5703.     return 0
  5704. } &&
  5705. complete -F _portupgrade $dirnames portupgrade
  5706.  
  5707. # FreeBSD portinstall completion
  5708. #
  5709. have portinstall &&
  5710. _portinstall()
  5711. {
  5712.     local cur portsdir prev indexfile
  5713.     local -a COMPREPLY2
  5714.  
  5715.     portsdir=${PORTSDIR:-/usr/ports}/
  5716.     cur=`_get_cword`
  5717.     prev=${COMP_WORDS[COMP_CWORD-1]}
  5718.     # First try INDEX-5
  5719.     indexfile=$portsdir/INDEX-5
  5720.     # Then INDEX if INDEX-5 does not exist or system is not FreeBSD 5.x
  5721.     [ "${OSTYPE%.*}" = "freebsd5" -a -f $indexfile ] ||
  5722.       indexfile=$portsdir/INDEX
  5723.  
  5724.     [ "$prev" = "-l" -o "$prev" = "-L" -o "$prev" = "-o" ] && return 0
  5725.  
  5726.     COMPREPLY=( $( egrep "^$cur" < $indexfile | cut -d'|' -f1 ) )
  5727.     COMPREPLY2=( $( egrep "^[^\|]+\|$portsdir$cur" < $indexfile | \
  5728.             cut -d'|' -f2 ) )
  5729.     COMPREPLY2=( ${COMPREPLY2[@]#$portsdir} )
  5730.     COMPREPLY=( "${COMPREPLY[@]}" "${COMPREPLY2[@]}" )
  5731.  
  5732.     return 0
  5733. } &&
  5734. complete -F _portinstall $dirnames portinstall
  5735.  
  5736. # Slackware Linux removepkg completion
  5737. #
  5738. have removepkg && [ -f /etc/slackware-version ] &&
  5739. _removepkg()
  5740. {
  5741.     local packages cur
  5742.  
  5743.     COMPREPLY=()
  5744.     cur=`_get_cword`
  5745.  
  5746.     COMPREPLY=( $( (cd /var/log/packages; compgen -f -- "$cur") ) )
  5747. } &&
  5748. complete -F _removepkg $filenames removepkg &&
  5749.     complete $dirnames -f -X '!*.tgz' installpkg upgradepkg explodepkg
  5750.  
  5751. # look(1) completion
  5752. #
  5753. have look &&
  5754. _look()
  5755. {
  5756.     local cur
  5757.  
  5758.     COMPREPLY=()
  5759.     cur=`_get_cword`
  5760.  
  5761.     if [ $COMP_CWORD = 1 ]; then
  5762.         COMPREPLY=( $( compgen -W '$(look $cur 2>/dev/null)' ) )
  5763.     fi
  5764. } &&
  5765. complete -F _look $default look
  5766.  
  5767. # ypcat(1) and ypmatch(1) completion
  5768. #
  5769. have ypmatch &&
  5770. _ypmatch()
  5771. {
  5772.     local cur map
  5773.  
  5774.     COMPREPLY=()
  5775.     cur=`_get_cword`
  5776.  
  5777.     [ $1 = ypcat ] && [ $COMP_CWORD -gt 1 ] && return 0
  5778.     [ $1 = ypmatch ] && [ $COMP_CWORD -gt 2 ] && return 0
  5779.  
  5780.     if [ $1 = ypmatch ] && [ $COMP_CWORD -eq 1 ] && \
  5781.        [ ${#COMP_WORDS[@]} -eq 3 ]; then
  5782.         map=${COMP_WORDS[2]}
  5783.         COMPREPLY=( $( compgen -W '$( ypcat $map | \
  5784.                         cut -d':' -f 1 )' -- $cur) )
  5785.     else
  5786.         [ $1 = ypmatch ] && [ $COMP_CWORD -ne 2 ] && return 0
  5787.         COMPREPLY=( $( compgen -W \
  5788.                   '$( echo $(ypcat -x | cut -d"\"" -f 2))' -- $cur))
  5789.     fi
  5790.  
  5791.     return 0
  5792. } &&
  5793. complete -F _ypmatch ypmatch ypcat
  5794.  
  5795. #xrandr(1) completion
  5796. #
  5797. have xrandr &&
  5798. _xrandr()
  5799. {
  5800.     local cur prev output modes
  5801.     COMPREPLY=()
  5802.     cur=`_get_cword`
  5803.     prev=${COMP_WORDS[COMP_CWORD-1]}
  5804.  
  5805.     case "$prev" in
  5806.         --output)
  5807.             local outputs=$(xrandr|grep 'connected'|awk '{print $1}')
  5808.             COMPREPLY=( $(compgen -W "$outputs" -- $cur))
  5809.             return 0
  5810.             ;;
  5811.         --mode)
  5812.             for(( i = 1; i < COMP_CWORD; i++ )); do
  5813.                 if [[ "${COMP_WORDS[i]}" == "--output" ]]; then
  5814.                     output=${COMP_WORDS[i+1]}
  5815.                     break
  5816.                 fi
  5817.             done
  5818.             modes=$(xrandr|sed -e "1,/$output/ d" \
  5819.             -e "/connected/,$ d"|awk '{print $1}')
  5820.             COMPREPLY=( $( compgen -W "$modes" -- $cur))
  5821.             return 0
  5822.             ;;
  5823.     esac
  5824.  
  5825.     case "$cur" in
  5826.         *)
  5827.             COMPREPLY=( $(compgen -W '-d -display -help -o \
  5828.                     --orientation -q --query -s --size\
  5829.                     -r --rate -v --version -x -y --screen \
  5830.                     --verbose --dryrun --prop --fb --fbmm --dpi \
  5831.                     --output --auto --mode --preferred --pos \
  5832.                     --reflect --rotate --left-of --right-of \
  5833.                     --above --below --same-as --set --off --crtc \
  5834.                     --newmode --rmmode --addmode --delmode' -- $cur))
  5835.             return 0
  5836.             ;;
  5837.     esac
  5838.  
  5839.     return 0
  5840. } &&
  5841. complete -F _xrandr xrandr
  5842.  
  5843.  
  5844.  
  5845. # mplayer(1) completion
  5846. #
  5847. have mplayer && {
  5848. _mplayer_options_list()
  5849. {
  5850.     cur=${cur%\\}
  5851.     COMPREPLY=( $( $1 $2 help 2> /dev/null | \
  5852.         sed -e '1,/^Available/d' | awk '{print $1}' | \
  5853.         sed -e 's/:$//' -e 's/^'${2#-}'$//' -e 's/<.*//' | \
  5854.         grep "^$cur" ) )
  5855. }
  5856.  
  5857. _mplayer()
  5858. {
  5859.     local cmd cur prev skinsdir IFS=$' \t\n' i j k=0
  5860.  
  5861.     COMPREPLY=()
  5862.     cmd=${COMP_WORDS[0]}
  5863.     cur=`_get_cword`
  5864.     prev=${COMP_WORDS[COMP_CWORD-1]}
  5865.  
  5866.     case "$prev" in
  5867.         -@(ac|afm|vc|vfm|ao|vo|vop|fstype|demuxer|vf|af))
  5868.             _mplayer_options_list mplayer $prev
  5869.             return 0
  5870.             ;;
  5871.         -@(oac|ovc|of))
  5872.             _mplayer_options_list mencoder $prev
  5873.             return 0
  5874.             ;;
  5875.         -audiofile)
  5876.             _filedir '@(mp3|MP3|mpg|MPG|ogg|OGG|w?(a)v|W?(A)V|mid|MID|flac|FLAC|mka|MKA|ape|APE)'
  5877.             return 0
  5878.             ;;
  5879.         -font)
  5880.             _filedir '@(desc|ttf)'
  5881.             return 0
  5882.             ;;
  5883.         -sub)
  5884.             _filedir '@(srt|SRT|sub|SUB|txt|TXT|utf|UTF|rar|RAR|mpsub|smi|js|ssa|SSA|aas|AAS)'
  5885.             return 0
  5886.             ;;
  5887.         -vobsub)
  5888.             _filedir '@(idx|IDX|ifo|IFO|sub|SUB)'
  5889.             IFS=$'\t\n'
  5890.             COMPREPLY=( $( for i in "${COMPREPLY[@]}"; do
  5891.                         if [ -f $i -a -r $i ]; then
  5892.                             echo ${i%.*}
  5893.                         else
  5894.                             echo $i
  5895.                         fi
  5896.                        done ) )
  5897.             IFS=$' \t\n'
  5898.             return 0
  5899.             ;;
  5900.         -ifo)
  5901.             _filedir '@(ifo|IFO)'
  5902.             return 0
  5903.             ;;
  5904.         -cuefile)
  5905.             _filedir '@(bin|BIN|cue|CUE)'
  5906.             return 0
  5907.             ;;
  5908.         -skin)
  5909.             # if you don't have installed mplayer in /usr you
  5910.             # may want to set the MPLAYER_SKINS_DIR global variable
  5911.             if [ -n "$MPLAYER_SKINS_DIR" ]; then
  5912.                 skinsdir=$MPLAYER_SKINS_DIR
  5913.             else
  5914.                 skinsdir=/usr/share/mplayer/Skin
  5915.             fi
  5916.  
  5917.             IFS=$'\t\n'
  5918.             for i in ~/.mplayer/Skin $skinsdir; do
  5919.                 if [ -d $i -a -r $i ]; then
  5920.                     for j in $( compgen -d $i/$cur ); do
  5921.                         COMPREPLY[$k]=${j#$i/}
  5922.                         k=$((++k))
  5923.                     done
  5924.                 fi
  5925.             done
  5926.             IFS=$' \t\n'
  5927.             return 0
  5928.             ;;
  5929.         -@(mixer|@(cdrom|dvd)-device|dvdauth|fb|zrdev))
  5930.             cur=${cur:=/dev/}
  5931.             _filedir
  5932.             return 0
  5933.             ;;
  5934.         -@(edl?(out)|lircconf|menu-cfg|playlist|csslib|dumpfile)| \
  5935.         -@(subfile|vobsub|aofile|fbmodeconfig|include|o|dvdkey)| \
  5936.         -passlogfile)
  5937.             _filedir
  5938.             return 0
  5939.             ;;
  5940.         -@(auto@(q|sync)|loop|menu-root|speed|sstep|aid|alang)| \
  5941.         -@(?(@(audio|sub)-)demuxer|bandwidth|cache|chapter)| \
  5942.         -@(dvd?(angle)|fps|frames|mc|passwd|user|sb|srate|ss|vcd)| \
  5943.         -@(vi?(d|vo)|ffactor|sid|slang|spu@(align|aa|gauss))| \
  5944.         -@(vobsubid|delay|bpp|brightness|contrast|dfbopts|display)| \
  5945.         -@(fbmode|geometry|guiwid|hue|icelayer|screen[wh]|wid)| \
  5946.         -@(monitor@(aspect|-@(dotclock|[hv]freq))|panscan|saturation)| \
  5947.         -@(xineramascreen|zr@(crop|norm|quality|[xy]doff|[vh]dec))| \
  5948.         -@(aspect|pp|x|y|xy|z|stereo|audio-@(density|delay|preload))| \
  5949.         -@(endpos|osdlevel|ffourcc|sws|channels|skiplimit|format)| \
  5950.         -@(ofps|aa@(driver|@(osd|sub)color)|vobsubout?(i@(ndex|d)))| \
  5951.         -sub@(-bg-@(alpha|color)|cp|delay|fps|pos|align|width)| \
  5952.         -sub@(font-@(blur|outline|autoscale|encoding|@(osd|text)-scale)))
  5953.             return 0
  5954.             ;;
  5955.         -lavdopts)
  5956.             COMPREPLY=( $( compgen -W 'ec er= bug= idct= gray' \
  5957.                     -- $cur ) )
  5958.             return 0
  5959.             ;;
  5960.         -lavcopts)
  5961.             COMPREPLY=( $( compgen -W 'vcodec= vqmin= vqscale= \
  5962.                     vqmax= mbqmin= mbqmax= vqdiff= \
  5963.                     vmax_b_frames= vme= vhq v4mv \
  5964.                     keyint= vb_strategy= vpass= \
  5965.                     aspect= vbitrate= vratetol= \
  5966.                     vrc_maxrate= vrc_minrate= \
  5967.                     vrc_buf_size= vb_qfactor= vi_qfactor= \
  5968.                     vb_qoffset= vi_qoffset= vqblur= \
  5969.                     vqcomp= vrc_eq= vrc_override= \
  5970.                     vrc_init_cplx= vqsquish= vlelim= \
  5971.                     vcelim= vstrict= vdpart vpsize= gray \
  5972.                     vfdct= idct= lumi_mask= dark_mask= \
  5973.                     tcplx_mask= scplx_mask= naq ildct \
  5974.                     format= pred qpel precmp= cmp= \
  5975.                     subcmp= predia= dia= trell last_pred= \
  5976.                     preme= subq= psnr mpeg_quant aic umv' \
  5977.                     -- $cur ) )
  5978.             return 0
  5979.             ;;
  5980.         -ssf)
  5981.             COMPREPLY=( $( compgen -W 'lgb= cgb= ls= cs= chs= \
  5982.                     cvs=' -- $cur ) )
  5983.             return 0
  5984.             ;;
  5985.         -jpeg)
  5986.             COMPREPLY=( $( compgen -W 'noprogressive progressive \
  5987.                     nobaseline baseline optimize= \
  5988.                     smooth= quality= outdir=' -- $cur ) )
  5989.             return 0
  5990.             ;;
  5991.         -xvidopts)
  5992.             COMPREPLY=( $( compgen -W 'dr2 nodr2' -- $cur ) )
  5993.             return 0
  5994.             ;;
  5995.         -xvidencopts)
  5996.             COMPREPLY=( $( compgen -W 'pass= bitrate= \
  5997.                     fixed_quant= me_quality= 4mv \
  5998.                     rc_reaction_delay_factor= \
  5999.                     rc_averaging_period= rc_buffer= \
  6000.                     quant_range= min_key_interval= \
  6001.                     max_key_interval= mpeg_quant \
  6002.                     mod_quant lumi_mask hintedme \
  6003.                     hintfile debug keyframe_boost= \
  6004.                     kfthreshold= kfreduction=' -- $cur ) )
  6005.             return 0
  6006.             ;;
  6007.         -divx4opts)
  6008.             COMPREPLY=( $( compgen -W 'br= key= deinterlace q= \
  6009.                     min_quant= max_quant= rc_period= \
  6010.                     rc_reaction_period= crispness= \
  6011.                     rc_reaction_ratio= pass= vbrpass= \
  6012.                     help' -- $cur ) )
  6013.             return 0
  6014.             ;;
  6015.         -info)
  6016.             COMPREPLY=( $( compgen -W 'name= artist= genre= \
  6017.                     subject= copyright= srcform= \
  6018.                     comment= help' -- $cur ) )
  6019.             return 0
  6020.             ;;
  6021.         -lameopts)
  6022.             COMPREPLY=( $( compgen -W 'vbr= abr cbr br= q= aq= \
  6023.                     ratio= vol= mode= padding= fast \
  6024.                     preset= help' -- $cur ) )
  6025.             return 0
  6026.             ;;
  6027.         -rawaudio)
  6028.             COMPREPLY=( $( compgen -W 'on channels= rate= \
  6029.                     samplesize= format=' -- $cur ) )
  6030.             return 0
  6031.             ;;
  6032.         -rawvideo)
  6033.             COMPREPLY=( $( compgen -W 'on fps= sqcif qcif cif \
  6034.                     4cif pal ntsc w= h= y420 yv12 yuy2 \
  6035.                     y8 format= size=' -- $cur ) )
  6036.             return 0
  6037.             ;;
  6038.         -aop)
  6039.             COMPREPLY=( $( compgen -W 'list= delay= format= fout= \
  6040.                     volume= mul= softclip' -- $cur ) )
  6041.             return 0
  6042.             ;;
  6043.         -dxr2)
  6044.             COMPREPLY=( $( compgen -W 'ar-mode= iec958-encoded \
  6045.                     iec958-decoded mute ucode= 75ire bw \
  6046.                     color interlaced macrovision= norm= \
  6047.                     square-pixel ccir601-pixel cr-left= \
  6048.                     cr-right= cr-top= cr-bot= ck-rmin= \
  6049.                     ck-gmin= ck-bmin= ck-rmax= ck-gmax= \
  6050.                     ck-bmax= ck-r= ck-g= ck-b= \
  6051.                     ignore-cache= ol-osd= olh-cor= \
  6052.                     olw-cor= olx-cor= oly-cor= overlay \
  6053.                     overlay-ratio= update-cache' -- $cur ))
  6054.             return 0
  6055.             ;;
  6056.         -tv)
  6057.             COMPREPLY=( $( compgen -W 'on noaudio driver= device= \
  6058.                     input= freq= outfmt= width= height= \
  6059.                     buffersize= norm= channel= chanlist= \
  6060.                     audiorate= forceaudio alsa amode= \
  6061.                     forcechan= adevice= audioid= volume= \
  6062.                     bass= treble= balance= fps= \
  6063.                     channels= immediatemode=' -- $cur ) )
  6064.             return 0
  6065.             ;;
  6066.         -mf)
  6067.             COMPREPLY=( $( compgen -W 'on w= h= fps= type=' \
  6068.                     -- $cur ) )
  6069.             return 0
  6070.             ;;
  6071.         -cdda)
  6072.             COMPREPLY=( $( compgen -W 'speed= paranoia= \
  6073.                     generic-dev= sector-size= overlap= \
  6074.                     toc-bias toc-offset= skip noskip' \
  6075.                     -- $cur ) )
  6076.             return 0
  6077.             ;;
  6078.         -input)
  6079.             COMPREPLY=( $( compgen -W 'conf= ar-delay ar-rate \
  6080.                     keylist cmdlist js-dev file' -- $cur ) )
  6081.             return 0
  6082.             ;;
  6083.         -af)
  6084.             COMPREPLY=( $( compgen -W 'resample resample= \
  6085.                     channels channels= format format= \
  6086.                     volume volume= delay delay= pan \
  6087.                     pan= sub sub= surround surround=' \
  6088.                     -- $cur ) )
  6089.             return 0
  6090.             ;;
  6091.         -af-adv)
  6092.             COMPREPLY=( $( compgen -W 'force= list=' -- $cur ) )
  6093.             return 0
  6094.             ;;
  6095.         -profile)
  6096.             _mplayer_options_list $cmd $prev
  6097.             return 0
  6098.             ;;
  6099.     esac
  6100.  
  6101.     case "$cur" in
  6102.         -*)
  6103.             COMPREPLY=( $( compgen -W '-aid -alang -audio-demuxer \
  6104.                     -audiofile -cdrom-device -cache -cdda \
  6105.                     -channels -chapter -csslib -demuxer \
  6106.                     -dvd -dvd-device -dvdangle -dvdauth \
  6107.                     -dvdkey -dvdnav -forceidx -fps -frames \
  6108.                     -hr-mp3-seek -idx -mc -mf -ni -nobps \
  6109.                     -passwd -rawaudio -rtsp-stream-over-tcp\
  6110.                     -skipopening -sb -srate -ss -tv -user \
  6111.                     -vcd -vid -vivo -ifo -ffactor -font \
  6112.                     -noautosub -nooverlapsub -sid -slang \
  6113.                     -sub -subcc -subcp -sub-demuxer \
  6114.                     -subdelay -subfont-autoscale \
  6115.                     -subfont-blur -subfont-encoding \
  6116.                     -subfont-osd-scale -subfont-outline \
  6117.                     -subfont-text-scale -subfps -subfile \
  6118.                     -subpos -unicode -utf8 -vobsub \
  6119.                     -vobsubid -ac -afm -aspect -flip \
  6120.                     -lavdopts -noaspect -nosound -pp -ssf \
  6121.                     -stereo -sws -vc -vfm -vop -xvidopts\
  6122.                     -xy -zoom -bandwidth -cuefile \
  6123.                     -noextbased -rawvideo -overlapsub \
  6124.                     -sub-bg-alpha -sub-bg-color -subalign \
  6125.                     -subwidth -sub-no-text-pp -spualign \
  6126.                     -spuaa -spugauss -pphelp -verbose -v \
  6127.                     -noni -noidx -nohr-mp3-seek -extbased \
  6128.                     -bps -oldpp -nozoom -noflip -nounicode \
  6129.                     -noutf8 -profile -vf -af' -- $cur ) )
  6130.             # add mplayer specific options
  6131.             [[ "$cmd" == @(?(g)mplayer) ]] && COMPREPLY=( "${COMPREPLY[@]}" \
  6132.                 $(compgen -W '-autoq -autosync -benchmark \
  6133.                     -framedrop -h -help -hardframedrop \
  6134.                     -identify -input -lircconf -loop \
  6135.                     -nojoystick -nolirc -nortc -playlist \
  6136.                     -quiet -really-quiet -rnd -sdp -skin \
  6137.                     -slave -softsleep -speed -sstep \
  6138.                     -use-stdin -dumpaudio -dumpfile \
  6139.                     -dumpstream -dumpvideo -dumpmicrodvdsub\
  6140.                     -dumpmpsub -dumpsrtsub -dumpjacosub \
  6141.                     -dumpsami -dumpsub -osdlevel -af \
  6142.                     -af-adv -ao -aofile -aop -delay -mixer \
  6143.                     -nowaveheader -bpp -brightness \
  6144.                     -contrast -display -double -dr -dxr2 \
  6145.                     -fb -fbmode -fbmodeconfig -forcexv -fs \
  6146.                     -geometry -hue -icelayer -jpeg \
  6147.                     -monitor-dotclock -monitor-hfreq \
  6148.                     -monitor-vfreq -monitoraspect \
  6149.                     -nograbpointer -noslices -panscan \
  6150.                     -rootwin -saturation -screenw -screenh \
  6151.                     -stop-xscreensaver -vm -vo -vsync -wid \
  6152.                     -xineramascreen -z -zrbw -zrcrop \
  6153.                     -zrdev -zrfd -zrhelp -zrnorm -zrquality \
  6154.                     -zrvdec -zrhdec -zrxdoff -zrydoff -y \
  6155.                     -edl -edlout -enqueue -fixed-vo \
  6156.                     -menu -menu-root -menu-cfg -shuffle \
  6157.                     -format -aahelp -dfbopts -fstype \
  6158.                     -guiwid -nokeepaspect -x --help \
  6159.                     -aaosdcolor -aasubcolor -aadriver \
  6160.                     -aaextended -aaeight' -- $cur) )
  6161.             # add mencoder specific options
  6162.             [[ "$cmd" = mencoder ]] && COMPREPLY=( "${COMPREPLY[@]}" \
  6163.                 $(compgen -W '-audio-density -audio-delay \
  6164.                     -audio-preload -divx4opts -endpos \
  6165.                     -ffourcc -include -info -lameopts \
  6166.                     -lavcopts -noskip -o -oac -ofps -ovc \
  6167.                     -passlogfile -skiplimit -vobsubout \
  6168.                     -vobsuboutindex -vobsuboutid \
  6169.                     -xvidencopts -of --verbose' -- $cur) )
  6170.             ;;
  6171.         *)
  6172.             _filedir '@(mp?(e)g|MP?(E)G|wm[av]|WM[AV]|avi|AVI|asf|ASF|vob|VOB|bin|BIN|dat|DAT|vcd|VCD|ps|PS|pes|PES|fl[iv]|FL[IV]|viv|VIV|rm?(j)|RM?(J)|ra?(m)|RA?(M)|yuv|YUV|mov|MOV|qt|QT|mp[234]|MP[234]|m4[av]|M4[AV]|og[gmavx]|OG[GMAVX]|w?(a)v|W?(A)V|dump|DUMP|mk[av]|MK[AV]|m4a|M4A|aac|AAC|m2v|M2V|dv|DV|rmvb|RMVB|mid|MID|ts|TS|3g[p2]|mpc|MPC|flac|FLAC|vro|VRO|divx|DIVX|aif?(f)|AIF?(F)|m2ts|M2TS|vdr|VDR|xvid|XVID|ape|APE)'
  6173.             ;;
  6174.     esac
  6175.  
  6176.     return 0
  6177. }
  6178. complete $filenames -F _mplayer mplayer mencoder gmplayer kplayer
  6179. }
  6180.  
  6181. # KDE dcop completion
  6182. #
  6183. have dcop &&
  6184. _dcop()
  6185. {
  6186.     local cur compstr
  6187.  
  6188.     COMPREPLY=()
  6189.     cur=`_get_cword`
  6190.     if [ -z $cur ]; then
  6191.         compstr=${COMP_WORDS[*]}
  6192.     else
  6193.         compstr=$( command echo ${COMP_WORDS[*]} | sed "s/ $cur$//" )
  6194.     fi
  6195.     COMPREPLY=( $( compgen -W '$( command $compstr | sed s/\(.*\)// )'  -- $cur ) )
  6196. } &&
  6197. complete -F _dcop dcop
  6198.  
  6199. # wvdial(1) completion
  6200. #
  6201. have wvdial &&
  6202. _wvdial()
  6203. {
  6204.     local cur prev config i IFS=$'\t\n'
  6205.  
  6206.     COMPREPLY=()
  6207.     cur=`_get_cword`
  6208.     prev=${COMP_WORDS[COMP_CWORD-1]}
  6209.  
  6210.     case $prev in
  6211.         --config)
  6212.             _filedir
  6213.             return 0
  6214.             ;;
  6215.     esac
  6216.  
  6217.     case $cur in
  6218.         -*)
  6219.             COMPREPLY=( $( compgen -W '--config --chat \
  6220.                 --remotename --help --version --no-syslog' \
  6221.                 -- $cur ) )
  6222.             ;;
  6223.         *)
  6224.             # start with global and personal config files
  6225.                    config="/etc/wvdial.conf"$'\t'"$HOME/.wvdialrc"
  6226.             # replace with command line config file if present
  6227.             for (( i=1; i < COMP_CWORD; i++ )); do
  6228.                 if [[ "${COMP_WORDS[i]}" == "--config" ]]; then
  6229.                     config=${COMP_WORDS[i+1]}
  6230.                     break
  6231.                 fi
  6232.             done
  6233.             # parse config files for sections and
  6234.             # remove default section
  6235.             COMPREPLY=( $( sed -ne \
  6236.                     "s|^\[Dialer \($cur.*\)\]$|\1|p" \
  6237.                     $config 2>/dev/null |grep -v '^Defaults$'))
  6238.             # escape spaces
  6239.             COMPREPLY=${COMPREPLY// /\\ }
  6240.             ;;
  6241.     esac
  6242.  
  6243. } &&
  6244. complete -F _wvdial wvdial
  6245.  
  6246. # gpg(1) completion
  6247. #
  6248. have gpg &&
  6249. _gpg()
  6250. {
  6251.     local cur prev
  6252.  
  6253.     COMPREPLY=()
  6254.     cur=`_get_cword`
  6255.     prev=${COMP_WORDS[COMP_CWORD-1]}
  6256.  
  6257.     case "$prev" in
  6258.     -@(s|-sign|-clearsign|-decrypt-files|-load-extension))
  6259.         _filedir
  6260.         return 0
  6261.         ;;
  6262.     --@(export|@(?(l|nr|nrl)sign|edit)-key))
  6263.         # return list of public keys
  6264.         COMPREPLY=( $( compgen -W "$( gpg --list-keys 2>/dev/null | sed -ne 's@^pub.*/\([^ ]*\).*$@\1@p;s@^.*\(<\([^>]*\)>\).*$@\2@p')" -- "$cur" ))
  6265.         return 0
  6266.         ;;
  6267.     -@(r|-recipient))
  6268.         COMPREPLY=( $( compgen -W "$( gpg --list-keys 2>/dev/null | sed -ne 's@^.*<\([^>]*\)>.*$@\1@p')" -- "$cur" ))
  6269.         if [ -e ~/.gnupg/gpg.conf ]; then
  6270.             COMPREPLY=( "${COMPREPLY[@]}" $( compgen -W "$( sed -ne 's@^[ \t]*group[ \t][ \t]*\([^=]*\).*$@\1@p' ~/.gnupg/gpg.conf  )" -- "$cur") )
  6271.         fi
  6272.         return 0
  6273.         ;;
  6274.     esac
  6275.  
  6276.     if [[ "$cur" == -* ]]; then
  6277.         COMPREPLY=( $( compgen -W '-s -b -e -f -c -d -a -r -u -Z -o -v\
  6278.                 -q -n -N $(gpg --dump-options)' -- $cur ) )
  6279.      fi
  6280.  
  6281. } &&
  6282. complete -F _gpg $default gpg
  6283.  
  6284. # iconv(1) completion
  6285. #
  6286. have iconv &&
  6287. _iconv()
  6288. {
  6289.     local cur prev
  6290.  
  6291.     COMPREPLY=()
  6292.     cur=`_get_cword`
  6293.     prev=${COMP_WORDS[COMP_CWORD-1]}
  6294.  
  6295.     case "$prev" in
  6296.         -@(f|t|-@(from|to)-code))
  6297.             COMPREPLY=( $( compgen -W \
  6298.                 '$( iconv --list | sed -e "s@//@@;" )' -- "$cur" ) )
  6299.             return 0
  6300.             ;;
  6301.     esac
  6302.  
  6303.  
  6304.     if [[ "$cur" = -* ]]; then
  6305.         COMPREPLY=( $( compgen -W '--from-code -f --to-code -t --list
  6306.         --output -o --verbose' -- "$cur" ) )
  6307.         return 0
  6308.     fi
  6309. } &&
  6310. complete -F _iconv $default iconv
  6311.  
  6312. # dict(1) completion
  6313. #
  6314. { have dict || have rdict; } && {
  6315. _dictdata()
  6316. {
  6317.     dict $host $port $1 2>/dev/null | sed -ne \
  6318.         's/^['$'\t '']['$'\t '']*\([^'$'\t '']*\).*$/\1/p'
  6319. }
  6320.  
  6321. _dict()
  6322. {
  6323.     local cur prev host port db dictfile
  6324.  
  6325.     COMPREPLY=()
  6326.     cur=`_get_cword`
  6327.     prev=${COMP_WORDS[COMP_CWORD-1]}
  6328.     dictfile=/usr/share/dict/words
  6329.  
  6330.     for (( i=1; i < COMP_CWORD; i++ )); do
  6331.         case "${COMP_WORDS[i]}" in
  6332.         -@(h|--host))
  6333.             host=${COMP_WORDS[i+1]}
  6334.             [ -n "$host" ] && host="-h $host"
  6335.             i=$((++i))
  6336.             ;;
  6337.         -@(p|-port))
  6338.             port=${COMP_WORDS[i+1]}
  6339.             [ -n "$port" ] && port="-p $port"
  6340.             i=$((++i))
  6341.             ;;
  6342.         -@(d|-database))
  6343.             db=${COMP_WORDS[i+1]}
  6344.             [ -n "$db" ] && host="-d $db"
  6345.             i=$((++i))
  6346.             ;;
  6347.         *)
  6348.             ;;
  6349.         esac
  6350.     done
  6351.  
  6352.     if [[ "$cur" = -* ]]; then
  6353.         COMPREPLY=( $( compgen -W '-h --host -p --port -d --database \
  6354.                    -m --match -s --strategy -c --config -C \
  6355.                    --nocorrect -D --dbs -S --strats -H \
  6356.                    --serverhelp -i --info -I --serverinfo \
  6357.                    -a --noauth -u --user -k --key -V --version \
  6358.                    -L --license --help -v --verbose -r --raw \
  6359.                    -P --pager --debug --html --pipesize --client' \
  6360.                    -- "$cur" ) )
  6361.         return 0
  6362.     fi
  6363.  
  6364.     case "$prev" in
  6365.     -@(d|-database|i|info))
  6366.         COMPREPLY=( $( compgen -W '$( _dictdata -D )' -- "$cur" ) )
  6367.         return 0
  6368.         ;;
  6369.     -@(s|-strategy))
  6370.         COMPREPLY=( $( compgen -W '$( _dictdata -S )' -- "$cur" ) )
  6371.         return 0
  6372.         ;;
  6373.     *)
  6374.         ;;
  6375.     esac
  6376.  
  6377.     [ -r $dictfile ] && \
  6378.         COMPREPLY=( $( compgen -W '$( cat $dictfile )' -- "$cur" ) )
  6379. }
  6380. complete -F _dict $default dict rdict
  6381. }
  6382.  
  6383. # cdrecord(1) completion
  6384. #
  6385. (have cdrecord || have wodim) &&
  6386. _cdrecord()
  6387. {
  6388.     local cur prev i generic_options track_options track_mode
  6389.  
  6390.     COMPREPLY=()
  6391.     cur=`_get_cword`
  6392.     prev=${COMP_WORDS[COMP_CWORD-1]}
  6393.  
  6394.     # foo=bar style option
  6395.     if [[ "$cur" == *=* ]]; then
  6396.         prev=${cur/=*/}
  6397.         cur=${cur/*=/}
  6398.         case "$prev" in
  6399.             @(text|cue)file)
  6400.                 _filedir
  6401.                 return 0
  6402.                 ;;
  6403.             blank)
  6404.                 COMPREPLY=( $( compgen -W 'help all fast \
  6405.                 track unreserve trtail unclose session' \
  6406.                 -- $cur ) )
  6407.                 return 0
  6408.                 ;;
  6409.             driveropts)
  6410.                 COMPREPLY=( $( compgen -W 'burnfree noburnfree\
  6411.                   varirec= audiomaster forcespeed noforcespeed\
  6412.                   speedread nospeedread singlesession \
  6413.                   nosinglesession hidecdr nohidecdr tattooinfo\
  6414.                   tattoofile=' -- $cur ) )
  6415.                 return 0
  6416.                 ;;
  6417.         esac
  6418.     fi
  6419.  
  6420.     generic_options=(-version -v -V -d -silent -s -force -immed -dummy \
  6421.              -dao -raw -raw96r -raw96p -raw16 -multi -msinfo -toc \
  6422.              -atip -fix -nofix -waiti -load -lock -eject -format \
  6423.              -setdropts -checkdrive -prcap -inq -scanbus -reset \
  6424.              -abort -overburn -ignsize -useinfo -packet -noclose \
  6425.              -text debug= kdebug= kd= minbuf= speed= blank= fs= \
  6426.              dev= gracetime= timeout= driver= driveropts= \
  6427.              defpregap= pktsize= mcn= textfile= cuefile=)
  6428.     track_options=(-audio -swab -data -mode2 -xa -xa1 -xa2 -xamix -cdi \
  6429.                -isosize -pad padsize= -nopad -shorttrack -noshorttrack\
  6430.                pregap= -preemp -nopreemp -copy -nocopy -scms tcsize= \
  6431.                isrc= index=)
  6432.     # look if previous was either a file or a track option
  6433.     track_mode=0
  6434.     if [ $COMP_CWORD -gt 1 ]; then
  6435.         if [ -f "$prev" ]; then
  6436.             track_mode=1
  6437.         else
  6438.             for (( i=0; i < ${#track_options[@]}; i++ )); do
  6439.                 if [[ "${track_options[i]}" == "$prev" ]]; then
  6440.                     track_mode=1
  6441.                     break
  6442.                 fi
  6443.             done
  6444.         fi
  6445.     fi
  6446.  
  6447.     # files are always eligible completion
  6448.     _filedir
  6449.     # track options are always available
  6450.     COMPREPLY=( "${COMPREPLY[@]}" $( compgen -W '${track_options[@]}' -- $cur ) )
  6451.     # general options are no more available after file or track option
  6452.     if [ $track_mode -eq 0 ]; then
  6453.         COMPREPLY=( "${COMPREPLY[@]}" \
  6454.                 $( compgen -W '${generic_options[@]}' -- $cur ) )
  6455.     fi
  6456.  
  6457. } &&
  6458. complete -F _cdrecord $filenames cdrecord wodim
  6459.  
  6460. # mkisofs(8) completion
  6461. #
  6462. (have mkisofs || have genisoimage) &&
  6463. _mkisofs()
  6464. {
  6465.     local cur prev
  6466.  
  6467.     COMPREPLY=()
  6468.     cur=`_get_cword`
  6469.     prev=${COMP_WORDS[COMP_CWORD-1]}
  6470.  
  6471.     case "$prev" in
  6472.         -@(o|abstract|biblio|check-session|copyright|log-file|root-info|prep-boot|*-list))
  6473.             _filedir
  6474.             return 0
  6475.             ;;
  6476.         -*-charset)
  6477.             COMPREPLY=( $( mkisofs -input-charset help 2>&1 | \
  6478.                     tail +3 | grep "^$cur") )
  6479.             return 0
  6480.             ;;
  6481.         -uid)
  6482.             _uids
  6483.             return 0
  6484.             ;;
  6485.         -gid)
  6486.             _gids
  6487.             return 0
  6488.             ;;
  6489.     esac
  6490.  
  6491.     if [[ "$cur" == -* ]]; then
  6492.         COMPREPLY=( $( compgen -W '-abstract -A -allow-lowercase \
  6493.                 -allow-multidot -biblio -cache-inodes \
  6494.                 -no-cache-inodes -b -eltorito-alt-boot -B -G \
  6495.                 -hard-disk-boot -no-emul-boot -no-boot \
  6496.                 -boot-load-seg -boot-load-size \
  6497.                 -boot-info-table -C -c -check-oldname \
  6498.                 -check-session -copyright -d -D -dir-mode \
  6499.                 -dvd-video -f -file-mode -gid -gui \
  6500.                 -graft-points -hide -hide-list -hidden \
  6501.                 -hidden-list -hide-joliet -hide-joliet-list \
  6502.                 -hide-joliet-trans-tbl -hide-rr-moved \
  6503.                 -input-charset -output-charset -iso-level -J \
  6504.                 -joliet-long -jcharset -l -L -log-file -m \
  6505.                 -exclude-list -max-iso9660-filenames -M -N \
  6506.                 -new-dir-mode -nobak -no-bak -force-rr -no-rr \
  6507.                 -no-split-symlink-components \
  6508.                 -no-split-symlink-fields -o -pad -no-pad \
  6509.                 -path-list -P -p -print-size -quiet -R -r \
  6510.                 -relaxed-filenames -sort -split-output \
  6511.                 -stream-media-size -stream-file-name -sysid -T\
  6512.                 -table-name -ucs-level -udf -uid \
  6513.                 -use-fileversion -U -no-iso-translate -V \
  6514.                 -volset -volset-size -volset-seqno -v -x -z \
  6515.                 -hfs -apple -map -magic -hfs-creator \
  6516.                 -hfs-type -probe -no-desktop -mac-name \
  6517.                 -boot-hfs-file -part -auto -cluster-size \
  6518.                 -hide-hfs -hide-hfs-list -hfs-volid \
  6519.                 -icon-position -root-info -prep-boot \
  6520.                 -input-hfs-charset -output-hfs-charset \
  6521.                 -hfs-unlock -hfs-bless -hfs-parms --cap \
  6522.                 --netatalk --double --ethershare --ushare \
  6523.                 --exchange --sgi --xinet --macbin --single \
  6524.                 --dave --sfm --osx-double --osx-hfs' -- $cur ))
  6525.     else
  6526.         _filedir
  6527.     fi
  6528.  
  6529. } &&
  6530. complete -F _mkisofs $filenames mkisofs genisoimage
  6531.  
  6532. # mc(1) completion
  6533. #
  6534. have mc &&
  6535. _mc()
  6536. {
  6537.     local cur prev
  6538.  
  6539.     COMPREPLY=()
  6540.     cur=`_get_cword`
  6541.     prev=${COMP_WORDS[COMP_CWORD-1]}
  6542.  
  6543.     # -name value style option
  6544.     case "$prev" in
  6545.         -@(e|v|l|P))
  6546.             _filedir
  6547.             return 0
  6548.             ;;
  6549.     esac
  6550.  
  6551.     # --name=value style option
  6552.     if [[ "$cur" == *=* ]]; then
  6553.         prev=${cur/=*/}
  6554.         cur=${cur/*=/}
  6555.         case "$prev" in
  6556.             --@(edit|view|ftplog|printwd))
  6557.                 _filedir
  6558.                 return 0
  6559.                 ;;
  6560.         esac
  6561.     fi
  6562.  
  6563.     if [[ "$cur" == -* ]]; then
  6564.         COMPREPLY=( $( compgen -W '-a --stickchars -b --nocolor -c \
  6565.             --color -C --colors= -d --nomouse -e --edit= -f \
  6566.             --datadir -k --resetsoft -l --ftplog= -P --printwd= \
  6567.             -s --slow -t --termcap -u --nosubshell -U --subshell \
  6568.             -v --view= -V --version -x --xterm -h --help' -- $cur ) )
  6569.     else
  6570.         _filedir -d
  6571.     fi
  6572. } &&
  6573. complete -F _mc $filenames mc
  6574.  
  6575. # yum(8) completion
  6576. #
  6577. have yum && {
  6578. _yum_list()
  6579. {
  6580.     if [[ "$1" == all ]] ; then
  6581.         # Try to strip in between headings like "Available Packages"
  6582.         # This will obviously only work for English :P
  6583.         COMPREPLY=( $( yum -d 0 -C list $1 "$cur*" 2>/dev/null | \
  6584.              grep -iv '^\(Available\|Installed\|Updated\) Packages' | \
  6585.              sed -e 's/[[:space:]].*//' ) )
  6586.     else
  6587.         # Drop first line (e.g. "Updated Packages")
  6588.         COMPREPLY=( $( yum -d 0 -C list $1 "$cur*" 2>/dev/null | \
  6589.             sed -ne 1d -e 's/[[:space:]].*//p' ) )
  6590.     fi
  6591. }
  6592.  
  6593. _yum()
  6594. {
  6595.     local cur prev special
  6596.  
  6597.     COMPREPLY=()
  6598.     cur=`_get_cword`
  6599.     prev=${COMP_WORDS[COMP_CWORD-1]}
  6600.  
  6601.     for (( i=0; i < ${#COMP_WORDS[@]}-1; i++ )); do
  6602.         if [[ ${COMP_WORDS[i]} == @(install|update|upgrade|remove|erase|deplist|info) ]]; then
  6603.             special=${COMP_WORDS[i]}
  6604.         fi
  6605.     done
  6606.  
  6607.     if [ -n "$special" ]; then
  6608.         case $special in
  6609.         install)
  6610.             _yum_list available
  6611.             return 0
  6612.             ;;
  6613.         deplist|info)
  6614.             _yum_list all
  6615.             return 0
  6616.             ;;
  6617.         upgrade|update)
  6618.             _yum_list updates
  6619.             return 0
  6620.             ;;
  6621.         remove|erase)
  6622.             # _rpm_installed_packages is not arch-qualified
  6623.             _yum_list installed
  6624.             return 0
  6625.             ;;
  6626.         esac
  6627.     fi
  6628.  
  6629.     case $cur in
  6630.         --*)
  6631.         COMPREPLY=( $( compgen -W '--installroot --version --help --enablerepo --disablerepo --exclude --obsoletes --noplugins' -- $cur ) )
  6632.         return 0
  6633.         ;;
  6634.         -*)
  6635.         COMPREPLY=( $( compgen -W '-c -e -d -y -t -R -C -h' -- $cur ) )
  6636.         return 0
  6637.         ;;
  6638.     esac
  6639.  
  6640.     case $prev in
  6641.         list)
  6642.         COMPREPLY=( $( compgen -W 'all available updates installed extras obsoletes recent' -- $cur ) )
  6643.         ;;
  6644.         clean)
  6645.         COMPREPLY=( $( compgen -W 'packages headers metadata cache dbcache all' -- $cur ) )
  6646.         ;;
  6647.         localinstall|localupdate)
  6648.             # TODO: should not match *src.rpm
  6649.         _filedir rpm
  6650.         ;;
  6651.         -c)
  6652.         _filedir
  6653.         ;;
  6654.         --installroot)
  6655.         _filedir -d
  6656.         ;;
  6657.         *)
  6658.         COMPREPLY=( $( compgen -W 'install update check-update upgrade remove list \
  6659.                         search info provides clean groupinstall groupupdate \
  6660.                         grouplist deplist erase groupinfo groupremove \
  6661.                         localinstall localupdate makecache resolvedep \
  6662.                         shell whatprovides' -- $cur ) )
  6663.         ;;
  6664.     esac
  6665. }
  6666. complete -F _yum $filenames yum
  6667.  
  6668. # yum-arch(8) completion
  6669. #
  6670. _yum_arch()
  6671. {
  6672.     local cur
  6673.     COMPREPLY=()
  6674.     cur=`_get_cword`
  6675.  
  6676.     case "$cur" in
  6677.     -*)
  6678.         COMPREPLY=( $( compgen -W '-d -v -vv -n -c -z -s -l -q' -- $cur ) )
  6679.         ;;
  6680.     *)
  6681.         _filedir -d
  6682.         ;;
  6683.     esac
  6684.  
  6685.     return 0
  6686.  
  6687. }
  6688. complete -F _yum_arch $filenames yum-arch
  6689. }
  6690.  
  6691. # ImageMagick completion
  6692. #
  6693. have convert && {
  6694. _ImageMagick()
  6695. {
  6696.     local prev
  6697.     prev=${COMP_WORDS[COMP_CWORD-1]}
  6698.  
  6699.     case "$prev" in
  6700.         -channel)
  6701.             COMPREPLY=( $( compgen -W 'Red Green Blue Opacity \
  6702.                 Matte Cyan Magenta Yellow Black' -- $cur ) )
  6703.             return 0
  6704.             ;;
  6705.         -colormap)
  6706.             COMPREPLY=( $( compgen -W 'shared private' -- $cur ) )
  6707.             return 0
  6708.             ;;
  6709.         -colorspace)
  6710.             COMPREPLY=( $( compgen -W 'GRAY OHTA RGB Transparent \
  6711.                 XYZ YCbCr YIQ YPbPr YUV CMYK' -- $cur ) )
  6712.             return 0
  6713.             ;;
  6714.         -compose)
  6715.             COMPREPLY=( $( compgen -W 'Over In Out Atop Xor Plus \
  6716.                 Minus Add Subtract Difference Multiply Bumpmap\
  6717.                 Copy CopyRed CopyGreen CopyBlue CopyOpacity' \
  6718.                 -- $cur ) )
  6719.             return 0
  6720.             ;;
  6721.         -compress)
  6722.             COMPREPLY=( $( compgen -W 'None BZip Fax Group4 JPEG \
  6723.                 Lossless LZW RLE Zip' -- $cur ) )
  6724.             return 0
  6725.             ;;
  6726.         -dispose)
  6727.             COMPREPLY=( $( compgen -W 'Undefined None Background \
  6728.                             Previous' -- $cur ) )
  6729.             return 0
  6730.             ;;
  6731.         -encoding)
  6732.             COMPREPLY=( $( compgen -W 'AdobeCustom AdobeExpert \
  6733.                 AdobeStandard AppleRoman BIG5 GB2312 Latin2 \
  6734.                 None SJIScode Symbol Unicode Wansung' -- $cur))
  6735.             return 0
  6736.             ;;
  6737.         -endian)
  6738.             COMPREPLY=( $( compgen -W 'MSB LSB' -- $cur ) )
  6739.             return 0
  6740.             ;;
  6741.         -filter)
  6742.             COMPREPLY=( $( compgen -W 'Point Box Triangle Hermite \
  6743.                 Hanning Hamming Blackman Gaussian Quadratic \
  6744.                 Cubic Catrom Mitchell Lanczos Bessel Sinc' \
  6745.                 -- $cur ) )
  6746.             return 0
  6747.             ;;
  6748.         -format)
  6749.             COMPREPLY=( $( convert -list format | \
  6750.                     awk '/ [r-][w-][+-] / {print $1}' | \
  6751.                     tr -d '*' | tr [:upper:] [:lower:] | \
  6752.                     grep "^$cur" ) )
  6753.             return 0
  6754.             ;;
  6755.         -gravity)
  6756.             COMPREPLY=( $( compgen -W 'Northwest North NorthEast \
  6757.                 West Center East SouthWest South SouthEast' \
  6758.                 -- $cur ) )
  6759.             return 0
  6760.             ;;
  6761.         -intent)
  6762.             COMPREPLY=( $( compgen -W 'Absolute Perceptual \
  6763.                     Relative Saturation' -- $cur ) )
  6764.             return 0
  6765.             ;;
  6766.         -interlace)
  6767.             COMPREPLY=( $( compgen -W 'None Line Plane Partition' \
  6768.                     -- $cur ) )
  6769.             return 0
  6770.             ;;
  6771.         -limit)
  6772.             COMPREPLY=( $( compgen -W 'Disk File Map Memory' \
  6773.                     -- $cur ) )
  6774.             return 0
  6775.             ;;
  6776.         -list)
  6777.             COMPREPLY=( $( compgen -W 'Delegate Format Magic \
  6778.                     Module Resource Type' -- $cur ) )
  6779.             return 0
  6780.             ;;
  6781.         -map)
  6782.             COMPREPLY=( $( compgen -W 'best default gray red \
  6783.                     green blue' -- $cur ) )
  6784.             _filedir
  6785.             return 0
  6786.             ;;
  6787.         -noise)
  6788.             COMPREPLY=( $( compgen -W 'Uniform Gaussian \
  6789.                     Multiplicative \
  6790.                 Impulse Laplacian Poisson' -- $cur ) )
  6791.             return 0
  6792.             ;;
  6793.         -preview)
  6794.             COMPREPLY=( $( compgen -W 'Rotate Shear Roll Hue \
  6795.                     Saturation Brightness Gamma Spiff \
  6796.                     Dull Grayscale Quantize Despeckle \
  6797.                     ReduceNoise AddNoise Sharpen Blur \
  6798.                     Treshold EdgeDetect Spread Shade \
  6799.                     Raise Segment Solarize Swirl Implode \
  6800.                     Wave OilPaint CharcoalDrawing JPEG' \
  6801.                     -- $cur ) )
  6802.             return 0
  6803.             ;;
  6804.         -@(mask|profile|texture|tile|write))
  6805.             _filedir
  6806.             return 0
  6807.             ;;
  6808.         -type)
  6809.             COMPREPLY=( $( compgen -W 'Bilevel Grayscale Palette \
  6810.                     PaletteMatte TrueColor TrueColorMatte \
  6811.                     ColorSeparation ColorSeparationlMatte \
  6812.                     Optimize' -- $cur ) )
  6813.             return 0
  6814.             ;;
  6815.         -units)
  6816.             COMPREPLY=( $( compgen -W 'Undefined PixelsPerInch \
  6817.                     PixelsPerCentimeter' -- $cur ) )
  6818.             return 0
  6819.             ;;
  6820.         -virtual-pixel)
  6821.             COMPREPLY=( $( compgen -W 'Constant Edge mirror tile' \
  6822.                     -- $cur ) )
  6823.             return 0
  6824.             ;;
  6825.         -visual)
  6826.             COMPREPLY=( $( compgen -W 'StaticGray GrayScale \
  6827.                     StaticColor PseudoColor TrueColor \
  6828.                     DirectColor defaut visualid' -- $cur ))
  6829.             return 0
  6830.             ;;
  6831.     esac
  6832. }
  6833.  
  6834. _convert()
  6835. {
  6836.     local cur
  6837.  
  6838.     COMPREPLY=()
  6839.     cur=`_get_cword`
  6840.  
  6841.     _ImageMagick
  6842.  
  6843.     if [[ "$cur" == -* ]]; then
  6844.         COMPREPLY=( $( compgen -W '-adaptive-blur -adaptive-resize \
  6845.             -adaptive-sharpen -adjoin -affine -alpha -annotate \
  6846.             -antialias -append -attenuate -authenticate \
  6847.             -auto-orient -average -background -bench -bias \
  6848.             -black-point-compensation -black-threshold \
  6849.             -blue-primary -blur -border -bordercolor -caption \
  6850.             -channel -charcoal -chop -clip -clip-mask -clip-path \
  6851.             -clone -clut -coalesce -colorize -colors -colorspace \
  6852.             -combine -comment -compose -composite -compress \
  6853.             -contrast -contrast-stretch -convolve -crop -cycle \
  6854.             -debug -decipher -deconstruct -define -delay -delete \
  6855.             -density -depth -despeckle -display -dispose -distort \
  6856.             -dither -draw -edge -emboss -encipher -encoding \
  6857.             -endian -enhance -equalize -evaluate -extent -extract \
  6858.             -family -fill -filter -flatten -flip -floodfill -flop \
  6859.             -font -format -frame -fuzz -fx -gamma -gaussian-blur \
  6860.             -geometry -gravity -green-primary -help -identify \
  6861.             -implode -insert -intent -interlace -interpolate \
  6862.             -label -lat -layers -level -limit -linear-stretch \
  6863.             -liquid-rescale -list -log -loop -map -mask \
  6864.             -mattecolor -median -modulate -monitor -monochrome \
  6865.             -morph -mosaic -motion-blur -negate -noise -normalize \
  6866.             -opaque -ordered-dither -orient -page -paint -ping \
  6867.             -pointsize -polaroid -posterize -preview -print \
  6868.             -process -profile -quality -quantize -quiet \
  6869.             -radial-blur -raise -random-threshold -recolor \
  6870.             -red-primary -regard-warnings -region -render -repage \
  6871.             -resample -resize -respect-parenthesis -reverse -roll \
  6872.             -rotate -sample -sampling-factor -scale -scene -seed \
  6873.             -segment -separate -sepia-tone -set -shade -shadow \
  6874.             -sharpen -shave -shear -sigmoidal-contrast -size \
  6875.             -sketch -solarize -splice -spread -stretch -strip \
  6876.             -stroke -strokewidth -style -swap -swirl -taint \
  6877.             -texture -threshold -thumbnail -tile -tile-offset \
  6878.             -tint -transform -transparent -transparent-color \
  6879.             -transpose -transverse -treedepth -trim -type \
  6880.             -undercolor -unique-colors -units -unsharp -verbose \
  6881.             -version -view -vignette -virtual-pixel -wave \
  6882.             -weight -white-point -white-threshold \
  6883.             -write' -- $cur ) )
  6884.     elif [[ "$cur" == +* ]]; then
  6885.         COMPREPLY=( $( compgen -W '+adjoin +append +compress \
  6886.             +contrast +debug +dither +endian +gamma +label +map \
  6887.             +mask +matte +negate +noise +page +raise +render \
  6888.             +write' -- $cur ) )
  6889.     else
  6890.         _filedir
  6891.     fi
  6892. }
  6893. complete -F _convert $filenames convert
  6894.  
  6895. _mogrify()
  6896. {
  6897.     local cur
  6898.  
  6899.     COMPREPLY=()
  6900.     cur=`_get_cword`
  6901.  
  6902.     _ImageMagick
  6903.  
  6904.     if [[ "$cur" == -* ]]; then
  6905.         COMPREPLY=( $( compgen -W '-adaptive-blur -adaptive-resize \
  6906.             -adaptive-sharpen -adjoin -affine -alpha -annotate \
  6907.             -antialias -attenuate -authenticate -auto-orient \
  6908.             -background -bias -black-point-compensation \
  6909.             -black-threshold -blue-primary -blur -border \
  6910.             -bordercolor -caption -channel -charcoal -chop -clip \
  6911.             -clip-mask -clip-path -clut -colorize -colors \
  6912.             -colorspace -comment -compose -compress -contrast \
  6913.             -contrast-stretch -convolve -cycle -debug -decipher \
  6914.             -define -delay -density -depth -despeckle -display \
  6915.             -dispose -distort -dither -draw -edge -emboss \
  6916.             -encipher -encoding -endian -enhance -equalize \
  6917.             -evaluate -extent -extract -family -fill -filter \
  6918.             -flip -floodfill -flop -font -format -frame -fuzz \
  6919.             -gamma -gaussian-blur -geometry -gravity \
  6920.             -green-primary -help -identify -implode -intent \
  6921.             -interlace -interpolate -label -lat -layers -level \
  6922.             -limit -linear-stretch -liquid-rescale -list -log \
  6923.             -loop -mask -mattecolor -median -modulate -monitor \
  6924.             -monochrome -motion-blur -negate -noise -normalize \
  6925.             -opaque -ordered-dither -orient -page -paint -path \
  6926.             -ping -pointsize -polaroid -posterize -preview -print \
  6927.             -profile -quality -quantize -quiet -radial-blur \
  6928.             -raise -random-threshold -recolor -red-primary \
  6929.             -regard-warnings -region -render -repage -resample \
  6930.             -resize -roll -rotate -sample -sampling-factor -scale \
  6931.             -scene -seed -segment -sepia-tone -set -shade -shadow \
  6932.             -sharpen -shave -shear -sigmoidal-contrast -size \
  6933.             -sketch -solarize -splice -spread -stretch -strip \
  6934.             -stroke -strokewidth -style -swirl -taint -texture \
  6935.             -threshold -thumbnail -tile -tile-offset -tint \
  6936.             -transform -transparent -transparent-color -transpose \
  6937.             -transverse -treedepth -trim -type -undercolor \
  6938.             -unique-colors -units -unsharp -verbose -version \
  6939.             -view -vignette -virtual-pixel -wave -weight \
  6940.             -white-point -white-threshold' -- $cur ) )
  6941.     elif [[ "$cur" == +* ]]; then
  6942.         COMPREPLY=( $( compgen -W '+compress +contrast +debug +dither \
  6943.             +endian +gamma +label +map +mask +matte +negate +page \
  6944.             +raise' -- $cur ) )
  6945.     else
  6946.         _filedir
  6947.     fi
  6948. }
  6949. complete -F _mogrify $filenames mogrify
  6950.  
  6951. _display()
  6952. {
  6953.     local cur
  6954.  
  6955.     COMPREPLY=()
  6956.     cur=`_get_cword`
  6957.  
  6958.     _ImageMagick
  6959.  
  6960.     if [[ "$cur" == -* ]]; then
  6961.         COMPREPLY=( $( compgen -W '-alpha -antialias -authenticate \
  6962.             -auto-orient -backdrop -background -border \
  6963.             -bordercolor -borderwidth -channel -clip \
  6964.             -clip-path -coalesce -colormap -colors -colorspace \
  6965.             -comment -compress -contrast -crop -debug -decipher \
  6966.             -define -delay -density -depth -despeckle -display \
  6967.             -dispose -dither -edge -endian -enhance -extract \
  6968.             -filter -flatten -flip -flop -font -foreground \
  6969.             -format -frame -gamma -geometry -help -iconGeometry \
  6970.             -iconic -identify -immutable -interlace -interpolate \
  6971.             -label -limit -list -log -loop -map -mattecolor \
  6972.             -monitor -monochrome -name -negate -page -profile \
  6973.             -quality -quantize -quiet -raise -regard-warnings \
  6974.             -remote -repage -resample -resize \
  6975.             -respect-parenthesis -roll -rotate -sample \
  6976.             -sampling-factor -scenes -seed -segment -set \
  6977.             -shared-memory -sharpen -size -strip -texture -title \
  6978.             -transparent-color -treedepth -trim -update \
  6979.             -usePixmap -verbose -version -virtual-pixel -visual \
  6980.             -window -window-group -write' -- $cur ) )
  6981.     elif [[ "$cur" == +* ]]; then
  6982.         COMPREPLY=( $( compgen -W '+compress +contrast +debug +dither \
  6983.             +endian +gamma +label +map +matte +negate +page \
  6984.             +raise +write' -- $cur ) )
  6985.     else
  6986.         _filedir
  6987.     fi
  6988. }
  6989. complete -F _display $filenames display
  6990.  
  6991. _animate()
  6992. {
  6993.     local cur
  6994.  
  6995.     COMPREPLY=()
  6996.     cur=`_get_cword`
  6997.  
  6998.     _ImageMagick
  6999.  
  7000.     if [[ "$cur" == -* ]]; then
  7001.         COMPREPLY=( $( compgen -W '-alpha -authenticate -backdrop \
  7002.             -background -bordercolor -borderwidth -channel \
  7003.             -coalesce -colormap -colors -colorspace -crop -debug \
  7004.             -decipher -define -delay -density -depth -display \
  7005.             -dispose -dither -extract -filter -flatten -font \
  7006.             -foreground -format -gamma -geometry -help \
  7007.             -iconGeometry -iconic -identify -immutable -interlace \
  7008.             -interpolate -limit -list -log -loop -map -mattecolor \
  7009.             -mattecolor -monitor -monochrome -name -page -pause \
  7010.             -quantize -quiet -regard-warnings -remote -repage \
  7011.             -resample -resize -respect-parenthesis -rotate \
  7012.             -sampling-factor -scenes -seed -set -shared-memory \
  7013.             -size -strip -title -transparent-color -treedepth \
  7014.             -trim -verbose -version -virtual-pixel -visual \
  7015.             -window' -- $cur ) )
  7016.     elif [[ "$cur" == +* ]]; then
  7017.         COMPREPLY=( $( compgen -W '+debug +dither +gamma +map +matte' -- $cur ) )
  7018.     else
  7019.         _filedir
  7020.     fi
  7021. }
  7022. complete -F _animate $filenames animate
  7023.  
  7024. _identify()
  7025. {
  7026.     local cur
  7027.  
  7028.     COMPREPLY=()
  7029.     cur=`_get_cword`
  7030.  
  7031.     _ImageMagick
  7032.  
  7033.     if [[ "$cur" == -* ]]; then
  7034.         COMPREPLY=( $( compgen -W '-alpha -antialias -authenticate \
  7035.             -channel -colorspace -crop -debug -define -density \
  7036.             -depth -extract -format -fuzz -gamma -help -interlace \
  7037.             -interpolate -limit -list -log -monitor -ping -quiet \
  7038.             -regard-warnings -respect-parenthesis \
  7039.             -sampling-factor -seed -set -size -strip -units \
  7040.             -verbose -version -virtual-pixel' -- $cur ) )
  7041.     elif [[ "$cur" == +* ]]; then
  7042.         COMPREPLY=( $( compgen -W '+debug' -- $cur ) )
  7043.     else
  7044.         _filedir
  7045.     fi
  7046. }
  7047. complete -F _identify $filenames identify
  7048.  
  7049. _montage()
  7050. {
  7051.     local cur
  7052.  
  7053.     COMPREPLY=()
  7054.     cur=`_get_cword`
  7055.  
  7056.     _ImageMagick
  7057.  
  7058.     if [[ "$cur" == -* ]]; then
  7059.         COMPREPLY=( $( compgen -W '-adjoin -affine -alpha \
  7060.             -authenticate -background -blue-primary -blur -border \
  7061.             -bordercolor -borderwidth -caption -channel -clone \
  7062.             -coalesce -colors -colorspace -comment -compose \
  7063.             -compress -crop -debug -define -density -depth \
  7064.             -display -dispose -dither -draw -encoding -endian \
  7065.             -extract -fill -filter -flatten -flip -flop -font \
  7066.             -format -frame -gamma -geometry -gravity \
  7067.             -green-primary -help -identify -interlace \
  7068.             -interpolate -label -limit -list -log -mattecolor \
  7069.             -mode -monitor -monochrome -origin -page -pointsize \
  7070.             -polaroid -profile -quality -quantize -quiet \
  7071.             -red-primary -regard-warnings -repage -resize \
  7072.             -respect-parenthesis -rotate -sampling-factor -scenes \
  7073.             -seed -set -shadow -size -strip -stroke -texture \
  7074.             -thumbnail -tile -title -transform -transparent \
  7075.             -transparent-color -treedepth -trim -type -units \
  7076.             -verbose -version -virtual-pixel \
  7077.             -white-point' -- $cur ) )
  7078.     elif [[ "$cur" == +* ]]; then
  7079.         COMPREPLY=( $( compgen -W '+adjoin +compress +debug +dither \
  7080.             +endian +gamma +label +matte +page' -- $cur ) )
  7081.     else
  7082.         _filedir
  7083.     fi
  7084. }
  7085. complete -F _montage $filenames montage
  7086.  
  7087. _composite()
  7088. {
  7089.     local cur
  7090.  
  7091.     COMPREPLY=()
  7092.     cur=`_get_cword`
  7093.  
  7094.     _ImageMagick
  7095.  
  7096.     if [[ "$cur" == -* ]]; then
  7097.         COMPREPLY=( $( compgen -W '-affine -alpha -authenticate \
  7098.             -blend -blue-primary -border -bordercolor -channel \
  7099.             -colors -colorspace -comment -compose -compress \
  7100.             -debug -decipher -define -density -depth -displace \
  7101.             -display -dispose -dissolve -dither -encipher \
  7102.             -encoding -endian -extract -filter -font -format \
  7103.             -geometry -gravity -green-primary -help -identify \
  7104.             -interlace -interpolate -label -limit -list -log \
  7105.             -monitor -monochrome -negate -page -profile -quality \
  7106.             -quantize -quiet -red-primary -regard-warnings \
  7107.             -repage -resize -respect-parenthesis -rotate \
  7108.             -sampling-factor -scene -seed -sharpen -shave -size \
  7109.             -stegano -stereo -strip -swap -thumbnail -tile \
  7110.             -transform -transparent-color -treedepth -type -units \
  7111.             -unsharp -verbose -version -virtual-pixel -watermark \
  7112.             -white-point -write' -- $cur ) )
  7113.     elif [[ "$cur" == +* ]]; then
  7114.         COMPREPLY=( $( compgen -W '+compress +debug +dither +endian +label \
  7115.             +matte +negate +page +write' -- $cur ) )
  7116.     else
  7117.         _filedir
  7118.     fi
  7119. }
  7120. complete -F _composite $filenames composite
  7121.  
  7122. _compare()
  7123. {
  7124.     local cur
  7125.  
  7126.     COMPREPLY=()
  7127.     cur=`_get_cword`
  7128.  
  7129.     _ImageMagick
  7130.  
  7131.     if [[ "$cur" == -* ]]; then
  7132.         COMPREPLY=( $( compgen -W '-alpha -authenticate -channel \
  7133.             -colorspace -compress -debug -decipher -define \
  7134.             -density -depth -encipher -extract -format -fuzz \
  7135.             -help -highlight-color -identify -interlace -limit \
  7136.             -list -log -metric -monitor -passphrase -profile \
  7137.             -quality -quantize -quiet -regard-warnings \
  7138.             -respect-parenthesis -sampling-factor -seed -set \
  7139.             -size -transparent-color -type -verbose -version \
  7140.             -virtual-pixel' -- $cur ) )
  7141.     elif [[ "$cur" == +* ]]; then
  7142.         COMPREPLY=( $( compgen -W '+debug' -- $cur ) )
  7143.     else
  7144.         _filedir
  7145.     fi
  7146. }
  7147. complete -F _compare $filenames compare
  7148.  
  7149. _conjure()
  7150. {
  7151.     local cur
  7152.  
  7153.     COMPREPLY=()
  7154.     cur=`_get_cword`
  7155.  
  7156.     _ImageMagick
  7157.  
  7158.     if [[ "$cur" == -* ]]; then
  7159.         COMPREPLY=( $( compgen -W '-debug -help -list -log -monitor \
  7160.             -quiet -regard-warnings -seed -verbose \
  7161.             -version' -- $cur ) )
  7162.     elif [[ "$cur" == +* ]]; then
  7163.         COMPREPLY=( $( compgen -W '+debug' -- $cur ) )
  7164.     else
  7165.         _filedir
  7166.     fi
  7167. }
  7168. complete -F _conjure $filenames conjure
  7169.  
  7170. _import()
  7171. {
  7172.     local cur
  7173.  
  7174.     COMPREPLY=()
  7175.     cur=`_get_cword`
  7176.  
  7177.     _ImageMagick
  7178.  
  7179.     if [[ "$cur" == -* ]]; then
  7180.         COMPREPLY=( $( compgen -W '-adjoin -annotate -border -channel \
  7181.             -colors -colorspace -comment -compress -crop -debug \
  7182.             -define -delay -density -depth -descend -display \
  7183.             -dispose -dither -encipher -encoding -endian -filter \
  7184.             -format -frame -geometry -gravity -help -identify \
  7185.             -interlace -interpolate -label -limit -list -log \
  7186.             -monitor -monochrome -negate -page -pause -pointsize \
  7187.             -quality -quantize -quiet -regard-warnings -repage \
  7188.             -resize -respect-parenthesis -rotate -sampling-factor \
  7189.             -scene -screen -seed -set -silent -snaps -strip \
  7190.             -thumbnail -transparent -transparent-color -treedepth \
  7191.             -trim -type -verbose -version -virtual-pixel \
  7192.             -window' -- $cur ) )
  7193.     elif [[ "$cur" == +* ]]; then
  7194.         COMPREPLY=( $( compgen -W '+debug' -- $cur ) )
  7195.     else
  7196.         _filedir
  7197.     fi
  7198. }
  7199. complete -F _import $filenames import
  7200.  
  7201. _stream()
  7202. {
  7203.     local cur
  7204.  
  7205.     COMPREPLY=()
  7206.     cur=`_get_cword`
  7207.  
  7208.     _ImageMagick
  7209.  
  7210.     if [[ "$cur" == -* ]]; then
  7211.         COMPREPLY=( $( compgen -W '-authenticate -channel -colorspace \
  7212.             -compress -debug -define -density -depth -extract \ 
  7213.             -help -identify -interlace -interpolate -limit -list \
  7214.             -log -map -monitor -quantize -quiet -regard-warnings \
  7215.             -respect-parenthesis -sampling-factor -seed -set \
  7216.             -size -storage-type -transparent-color -verbose \
  7217.             -version -virtual-pixel' -- $cur ) )
  7218.     elif [[ "$cur" == +* ]]; then
  7219.         COMPREPLY=( $( compgen -W '+debug' -- $cur ) )
  7220.     else
  7221.         _filedir
  7222.     fi
  7223. }
  7224. complete -F _stream $filenames stream
  7225. }
  7226.  
  7227. # dd(1) completion
  7228. #
  7229. have dd &&
  7230. _dd()
  7231. {
  7232.      local cur
  7233.  
  7234.      COMPREPLY=()
  7235.      cur=`_get_cword`
  7236.  
  7237.      case "$cur" in
  7238.      if=*|of=*)
  7239.          cur=${cur#*=}
  7240.          _filedir
  7241.          return 0
  7242.          ;;
  7243.      conv=*)
  7244.          cur=${cur#*=}
  7245.          COMPREPLY=( $( compgen -W 'ascii ebcdic ibm block unblock \
  7246.                 lcase notrunc ucase swab noerror sync' \
  7247.                 -- $cur ) )
  7248.          return 0
  7249.          ;;
  7250.      esac
  7251.  
  7252.      _expand || return 0
  7253.  
  7254.      COMPREPLY=( $( compgen -W '--help --version' -- $cur ) \
  7255.              $( compgen -W 'bs cbs conv count ibs if obs of seek skip'\
  7256.                 -S '=' -- $cur ) )
  7257. } &&
  7258. complete -F _dd $nospace $filenames dd
  7259.  
  7260. # CUPS cancel(1) completion
  7261. #
  7262. have cancel &&
  7263. _cancel()
  7264. {
  7265.     local cur
  7266.  
  7267.     COMPREPLY=()
  7268.     cur=`_get_cword`
  7269.  
  7270.     COMPREPLY=( $( lpstat | cut -d' ' -f1 | grep "^$cur" ) )
  7271. } &&
  7272. complete -F _cancel $filenames cancel
  7273.  
  7274. # aspell(1) completion
  7275. #
  7276. have aspell && {
  7277. _aspell_dictionary()
  7278. {
  7279.     local datadir
  7280.     datadir=/usr/lib/aspell
  7281.     COMPREPLY=( $( command ls $datadir/*.@(multi|alias) ) )
  7282.     COMPREPLY=( ${COMPREPLY[@]%.@(multi|alias)} )
  7283.     COMPREPLY=( $( compgen -W '${COMPREPLY[@]#$datadir/}' -- $cur ) )
  7284. }
  7285.  
  7286. _aspell()
  7287. {
  7288.     local cur prev
  7289.  
  7290.     COMPREPLY=()
  7291.     cur=`_get_cword`
  7292.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7293.  
  7294.     # --name value style option
  7295.     case "$prev" in
  7296.         @(-c|-p|check))
  7297.             _filedir
  7298.             return 0
  7299.             ;;
  7300.         @(dump|create|merge))
  7301.             COMPREPLY=( $( compgen -W 'master personal repl' -- $cur ) )
  7302.             return 0
  7303.             ;;
  7304.         -d)
  7305.             _aspell_dictionary
  7306.             return 0
  7307.             ;;
  7308.     esac
  7309.  
  7310.     # --name=value style option
  7311.     if [[ "$cur" == *=* ]]; then
  7312.         prev=${cur/=*/}
  7313.         cur=${cur/*=/}
  7314.         case "$prev" in
  7315.             --@(conf|personal|repl|per-conf))
  7316.                 _filedir
  7317.                 return 0
  7318.                 ;;
  7319.             --@(conf-dir|data-dir|dict-dir|home-dir|local-data-dir|prefix))
  7320.                 _filedir -d
  7321.                 return 0
  7322.                 ;;
  7323.             --master)
  7324.                 _aspell_dictionary
  7325.                 return 0
  7326.                 ;;
  7327.             --mode)
  7328.                 COMPREPLY=( $( compgen -W 'none url email sgml tex' -- $cur ) )
  7329.                 return 0
  7330.                 ;;
  7331.             --sug-mode)
  7332.                 COMPREPLY=( $( compgen -W 'ultra fast normal bad-speller' -- $cur ) )
  7333.                 return 0
  7334.                 ;;
  7335.             --keymapping)
  7336.                 COMPREPLY=( $( compgen -W 'aspell ispell' -- $cur ) )
  7337.                 return 0
  7338.                 ;;
  7339.         esac
  7340.     fi
  7341.  
  7342.     if [[ "$cur" == -* ]]; then
  7343.         COMPREPLY=( $( compgen -W '--conf= --conf-dir= --data-dir= --dict-dir= \
  7344.             --encoding= --add-filter= --rem-filter= --mode= -e \
  7345.             -H -t --add-extra-dicts= --rem-extra-dicts= \
  7346.             --home-dir= -W --ignore= --ignore-accents \
  7347.             --dont-ignore-accents --ignore-case --dont-ignore-case \
  7348.             --ignore-repl --dont-ignore-repl --jargon= --keyboard= \
  7349.             --lang= --language-tag= --local-data-dir= -d --master= \
  7350.             --module= --add-module-search-order= \
  7351.             --rem-module-search-order= --per-conf= -p --personal= \
  7352.             --prefix= --repl= -C -B --run-together --dont-run-together \
  7353.             --run-together-limit= --run-together-min= --save-repl \
  7354.             --dont-save-repl --set-prefix --dont-set-prefix --size= \
  7355.             --spelling= --strip-accents --dont-strip-accents \
  7356.             --sug-mode= --add-word-list-path= --rem-word-list-path= \
  7357.             -b -x --backup -b|-x --dont-backup --reverse --dont-reverse \
  7358.             --time --dont-time --keymapping= --add-email-quote= \
  7359.             --rem-email-quote= --email-margin= --add-tex-command= \
  7360.             --rem-tex-command= --tex-check-comments \
  7361.             --dont-tex-check-comments --add-tex-extension= \
  7362.             --rem-tex-extension= --add-sgml-check= --rem-sgml-check= \
  7363.             --add-sgml-extension= --rem-sgml-extension=' -- $cur ) )
  7364.     else
  7365.         COMPREPLY=( $( compgen -W '-? help -c check -a pipe -l list \
  7366.             config config soundslike filter -v version dump \
  7367.             create merge' -- $cur ) )
  7368.     fi
  7369.  
  7370. }
  7371. complete -F _aspell $filenames aspell
  7372. }
  7373.  
  7374. # xmms(1) completion
  7375. #
  7376. have xmms &&
  7377. _xmms()
  7378. {
  7379.     local cur
  7380.  
  7381.     COMPREPLY=()
  7382.     cur=`_get_cword`
  7383.  
  7384.     if [[ "$cur" == -* ]]; then
  7385.         COMPREPLY=( $( compgen -W '-h --help -r --rew -p --play \
  7386.             -u --pause -s --stop -t --play-pause -f --fwd -e \
  7387.             --enqueue -m --show-main-window -i --sm-client-id \
  7388.             -v --version' -- $cur ) )
  7389.     else
  7390.         _filedir '@(mp[23]|MP[23]|ogg|OGG|wav|WAV|pls|m3u|xm|mod|s[3t]m|it|mtm|ult|flac)'
  7391.  
  7392.     fi
  7393.  
  7394. } &&
  7395. complete -F _xmms $filenames xmms
  7396.  
  7397. # info(1) completion
  7398. #
  7399. have info &&
  7400. _info()
  7401. {
  7402.     local cur infopath
  7403.  
  7404.     COMPREPLY=()
  7405.     cur=`_get_cword`
  7406.  
  7407.     _expand || return 0
  7408.  
  7409.     # default completion if parameter contains /
  7410.     if [[ "$cur" == */* ]]; then
  7411.         _filedir
  7412.         return 0
  7413.     fi
  7414.  
  7415.     infopath='/usr/share/info'
  7416.  
  7417.     if [ "${INFOPATH: -1:1}" == ':' ]; then
  7418.         infopath=${INFOPATH}${infopath}
  7419.     elif [ ${INFOPATH:+set} ]; then
  7420.         infopath=$INFOPATH
  7421.     fi
  7422.  
  7423.     infopath=$infopath:
  7424.     if [ -n "$cur" ]; then
  7425.         infopath="${infopath//://$cur* }"
  7426.     else
  7427.         infopath="${infopath//:// }"
  7428.     fi
  7429.  
  7430.     # redirect stderr for when path doesn't exist
  7431.     COMPREPLY=( $( eval command ls "$infopath" 2>/dev/null ) )
  7432.     # weed out directory path names and paths to info pages
  7433.     COMPREPLY=( ${COMPREPLY[@]##*/?(:)} )
  7434.     # weed out info dir file
  7435.     for (( i=0 ; i < ${#COMPREPLY[@]} ; ++i )); do
  7436.         if [ "${COMPREPLY[$i]}" == 'dir' ]; then
  7437.             unset COMPREPLY[$i];
  7438.         fi;
  7439.     done
  7440.     # strip suffix from info pages
  7441.     COMPREPLY=( ${COMPREPLY[@]%.@(gz|bz2|lzma)} )
  7442.     COMPREPLY=( $( compgen -W '${COMPREPLY[@]%.*}' -- "${cur//\\\\/}" ) )
  7443.  
  7444.     return 0
  7445. } &&
  7446. complete -F _info $filenames info
  7447.  
  7448. # dhclient(1) completion
  7449. #
  7450. have dhclient && _dhclient()
  7451. {
  7452.     local cur prev
  7453.  
  7454.     COMPREPLY=()
  7455.     cur=`_get_cword`
  7456.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7457.  
  7458.     case "$prev" in
  7459.         -@(cf|lf|pf|sf))
  7460.             _filedir
  7461.             return 0
  7462.             ;;
  7463.         -s)
  7464.             _known_hosts
  7465.             return 0
  7466.             ;;
  7467.     esac
  7468.  
  7469.     if [[ "$cur" == -* ]]; then
  7470.         COMPREPLY=( $( compgen -W '-p -d -q -1 -r -lf -pf \
  7471.             -cf -sf -s -g -n -nw -w' -- $cur ) )
  7472.     else
  7473.         _available_interfaces
  7474.     fi
  7475. } &&
  7476. complete -F _dhclient dhclient
  7477.  
  7478. # lvm(8) completion
  7479. #
  7480. have lvm && {
  7481. _volumegroups()
  7482. {
  7483.     COMPREPLY=( $(compgen -W "$( vgscan 2>/dev/null | \
  7484.         sed -n -e 's|.*Found.*"\(.*\)".*$|\1|p' )" -- $cur ) )
  7485. }
  7486.  
  7487. _physicalvolumes()
  7488. {
  7489.     COMPREPLY=( $(compgen -W "$( pvscan 2>/dev/null | \
  7490.         sed -n -e 's|^.*PV \(.*\) VG.*$|\1|p' )" -- $cur ) )
  7491. }
  7492.  
  7493. _logicalvolumes()
  7494. {
  7495.     COMPREPLY=( $(compgen -W "$( lvscan 2>/dev/null | \
  7496.         sed -n -e "s|^.*'\(.*\)'.*$|\1|p" )" -- $cur ) )
  7497. }
  7498.  
  7499. _units()
  7500. {
  7501.     COMPREPLY=( $( compgen -W 'h s b k m g t H K M G T' -- $cur ) )
  7502. }
  7503.  
  7504. _sizes()
  7505. {
  7506.     COMPREPLY=( $( compgen -W 'k K m M g G t T' -- $cur ) )
  7507. }
  7508.  
  7509. _args()
  7510. {
  7511.     args=0
  7512.     if [[ "${COMP_WORDS[0]}" == lvm ]]; then
  7513.         offset=2
  7514.     else
  7515.         offset=1
  7516.     fi
  7517.     for (( i=$offset; i < COMP_CWORD; i++ )); do
  7518.         if [[ "${COMP_WORDS[i]}" != -* ]]; then
  7519.             args=$(($args + 1))
  7520.         fi
  7521.     done
  7522. }
  7523.  
  7524. _lvmdiskscan()
  7525. {
  7526.     local cur
  7527.  
  7528.     COMPREPLY=()
  7529.     cur=`_get_cword`
  7530.  
  7531.     if [[ "$cur" == -* ]]; then
  7532.         COMPREPLY=( $( compgen -W '-d --debug -h -? --help -l \
  7533.             --lvmpartition -v --verbose --version' -- $cur ) )
  7534.     fi
  7535. }
  7536. complete -F _lvmdiskscan lvmdiskscan
  7537.  
  7538. _pvscan()
  7539. {
  7540.     local cur
  7541.  
  7542.     COMPREPLY=()
  7543.     cur=`_get_cword`
  7544.  
  7545.     if [[ "$cur" == -* ]]; then
  7546.         COMPREPLY=( $( compgen -W '-d --debug -e \
  7547.             --exported -n --novolumegroup -h -? \
  7548.             --help --ignorelockingfailure -P \
  7549.             --partial -s --short -u --uuid -v \
  7550.             --verbose --version' -- $cur ) )
  7551.     fi
  7552. }
  7553. complete -F _pvscan pvscan
  7554.  
  7555. _pvs()
  7556. {
  7557.     local cur prev
  7558.  
  7559.     COMPREPLY=()
  7560.     cur=`_get_cword`
  7561.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7562.  
  7563.     case "$prev" in
  7564.         -@(o|O|-options|-sort))
  7565.             COMPREPLY=( $( compgen -W 'pv_fmt pv_uuid \
  7566.                 pv_size pv_free pv_used pv_name \
  7567.                 pv_attr pv_pe_count \
  7568.                 pv_pe_alloc_count' -- $cur ) )
  7569.             return 0
  7570.             ;;
  7571.         --units)
  7572.             _units
  7573.             return 0
  7574.             ;;
  7575.     esac
  7576.  
  7577.     if [[ "$cur" == -* ]]; then
  7578.         COMPREPLY=( $( compgen -W '--aligned -a --all -d --debug \
  7579.             -h -? --help --ignorelockingfailure --noheadings \
  7580.             --nosuffix -o --options -O --sort \
  7581.             --separator --unbuffered --units \
  7582.             -v --verbose --version' -- $cur ) )
  7583.     else
  7584.         _physicalvolumes
  7585.     fi
  7586. }
  7587. complete -F _pvs pvs
  7588.  
  7589. _pvdisplay()
  7590. {
  7591.     local cur prev
  7592.  
  7593.     COMPREPLY=()
  7594.     cur=`_get_cword`
  7595.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7596.  
  7597.     case "$prev" in
  7598.         --units)
  7599.             _units
  7600.             return 0
  7601.             ;;
  7602.     esac
  7603.  
  7604.     if [[ "$cur" == -* ]]; then
  7605.         COMPREPLY=( $( compgen -W '-c --colon -C --columns --units \
  7606.             -v --verbose -d --debug -h --help --version' -- $cur ) )
  7607.     else
  7608.         _physicalvolumes
  7609.     fi
  7610. }
  7611. complete -F _pvdisplay pvdisplay
  7612.  
  7613. _pvchange()
  7614. {
  7615.     local cur prev
  7616.  
  7617.     COMPREPLY=()
  7618.     cur=`_get_cword`
  7619.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7620.  
  7621.     case "$prev" in
  7622.         -@(A|x|-autobackup|--allocatable))
  7623.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  7624.             return 0
  7625.             ;;
  7626.     esac
  7627.  
  7628.     if [[ "$cur" == -* ]]; then
  7629.         COMPREPLY=( $( compgen -W '-a --all -A --autobackup \
  7630.             -d --debug -h --help -t --test -u --uuid -x \
  7631.             --allocatable -v --verbose --addtag --deltag \
  7632.             --version' -- $cur ) )
  7633.     else
  7634.         _physicalvolumes
  7635.     fi
  7636. }
  7637. complete -F _pvchange pvchange
  7638.  
  7639. _pvcreate()
  7640. {
  7641.     local cur prev
  7642.  
  7643.     COMPREPLY=()
  7644.     cur=`_get_cword`
  7645.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7646.  
  7647.     case "$prev" in
  7648.         --restorefile)
  7649.             _filedir
  7650.             return 0
  7651.             ;;
  7652.         -@(M|-metadatatype))
  7653.             COMPREPLY=( $( compgen -W '1 2' -- $cur ) )
  7654.             return 0
  7655.             ;;
  7656.         --metadatacopies)
  7657.             COMPREPLY=( $( compgen -W '0 1 2' -- $cur ) )
  7658.             return 0
  7659.             ;;
  7660.         --@(metadatasize|setphysicalvolumesize))
  7661.             _sizes
  7662.             return 0
  7663.             ;;
  7664.     esac
  7665.  
  7666.     if [[ "$cur" == -* ]]; then
  7667.         COMPREPLY=( $( compgen -W '--restorefile -d --debug -f \
  7668.             --force -h -? --help --labelsector -M --metadatatype \
  7669.             --metadatacopies --metadatasize \
  7670.             --setphysicalvolumesize -t --test -u --uuid uuid -v \
  7671.             --verbose -y --yes --version' -- $cur ) )
  7672.     else
  7673.         _physicalvolumes
  7674.     fi
  7675. }
  7676. complete -F _pvcreate pvcreate
  7677.  
  7678. _pvmove()
  7679. {
  7680.     local cur prev
  7681.  
  7682.     COMPREPLY=()
  7683.     cur=`_get_cword`
  7684.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7685.  
  7686.     case "$prev" in
  7687.         -@(A|-autobackup))
  7688.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  7689.             return 0
  7690.             ;;
  7691.         -@(n|-name))
  7692.             _logicalvolumes
  7693.             return 0
  7694.     esac
  7695.  
  7696.     if [[ "$cur" == -* ]]; then
  7697.         COMPREPLY=( $( compgen -W '--abort -A --autobackup \
  7698.             -b --background -d --debug -f --force -h -? \
  7699.             --help -i --interval -t --test -v --verbose \
  7700.             --version -n --name' -- $cur ) )
  7701.     else
  7702.         _physicalvolumes
  7703.     fi
  7704. }
  7705. complete -F _pvmove pvmove
  7706.  
  7707. _pvremove()
  7708. {
  7709.     local cur
  7710.  
  7711.     COMPREPLY=()
  7712.     cur=`_get_cword`
  7713.  
  7714.     if [[ "$cur" == -* ]]; then
  7715.         COMPREPLY=( $( compgen -W '-d --debug -f --force -h -? \
  7716.             --help -y --yes -t --test -v --verbose \
  7717.             --version' -- $cur ) )
  7718.     else
  7719.         _physicalvolumes
  7720.     fi
  7721. }
  7722. complete -F _pvremove pvremove
  7723.  
  7724. _vgscan()
  7725. {
  7726.     local cur
  7727.  
  7728.     COMPREPLY=()
  7729.     cur=`_get_cword`
  7730.  
  7731.     if [[ "$cur" == -* ]]; then
  7732.         COMPREPLY=( $( compgen -W '-d --debug -h --help \
  7733.             --ignorelockingfailure --mknodes -P \
  7734.             --partial -v --verbose --version' -- $cur ) )
  7735.     fi
  7736. }
  7737. complete -F _vgscan vgscan
  7738.  
  7739. _vgs()
  7740. {
  7741.     local cur prev
  7742.  
  7743.     COMPREPLY=()
  7744.     cur=`_get_cword`
  7745.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7746.  
  7747.     case "$prev" in
  7748.         -@(o|O|-options|-sort))
  7749.             COMPREPLY=( $( compgen -W 'vg_fmt vg_uuid vg_name \
  7750.                 vg_attr vg_size vg_free vg_sysid \
  7751.                 vg_extent_size vg_extent_count vg_free_count \
  7752.                 max_lv max_pv pv_count lv_count snap_count \
  7753.                 vg_seqno' -- $cur ) )
  7754.             return 0
  7755.             ;;
  7756.         --units)
  7757.             _units
  7758.             return 0
  7759.             ;;
  7760.     esac
  7761.  
  7762.     if [[ "$cur" == -* ]]; then
  7763.         COMPREPLY=( $( compgen -W '--aligned -d --debug \
  7764.             -h --help --ignorelockingfailure --noheadings \
  7765.             --nosuffix -o --options -O --sort -P --partial \
  7766.             --separator --unbuffered --units \
  7767.             -v --verbose --version' -- $cur ) )
  7768.     else
  7769.         _volumegroups
  7770.     fi
  7771. }
  7772. complete -F _vgs vgs
  7773.  
  7774. _vgdisplay()
  7775. {
  7776.     local cur prev
  7777.  
  7778.     COMPREPLY=()
  7779.     cur=`_get_cword`
  7780.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7781.  
  7782.     case "$prev" in
  7783.         --units)
  7784.             _units
  7785.             return 0
  7786.             ;;
  7787.     esac
  7788.  
  7789.     if [[ "$cur" == -* ]]; then
  7790.         COMPREPLY=( $( compgen -W '-c --colon -C --columns --units \
  7791.             -P --partial -A --activevolumegroups -v --verbose \
  7792.             -d --debug -h --help --version' -- $cur ) )
  7793.     else
  7794.         _volumegroups
  7795.     fi
  7796. }
  7797. complete -F _vgdisplay vgdisplay
  7798.  
  7799. _vgchange()
  7800. {
  7801.     local cur prev
  7802.  
  7803.     COMPREPLY=()
  7804.     cur=`_get_cword`
  7805.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7806.  
  7807.     case "$prev" in
  7808.         -@(a|A|x|-available|-autobackup|-resizeable))
  7809.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  7810.             return 0
  7811.             ;;
  7812.     esac
  7813.  
  7814.     if [[ "$cur" == -* ]]; then
  7815.         COMPREPLY=( $( compgen -W '-A --autobackup --alloc -P \
  7816.             --partial -d --debug -h --help --ignorelockingfailure \
  7817.             -t --test -u --uuid -v --verbose --version -a \
  7818.             --available -x --resizeable -l --logicalvolume \
  7819.             --addtag --deltag' -- $cur ) )
  7820.     else
  7821.         _volumegroups
  7822.     fi
  7823. }
  7824. complete -F _vgchange vgchange
  7825.  
  7826. _vgcreate()
  7827. {
  7828.     local cur prev
  7829.  
  7830.     COMPREPLY=()
  7831.     cur=`_get_cword`
  7832.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7833.  
  7834.     case "$prev" in
  7835.         -@(A|-autobackup))
  7836.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  7837.             return 0
  7838.             ;;
  7839.         -@(M|-metadatatype))
  7840.             COMPREPLY=( $( compgen -W '1 2' -- $cur ) )
  7841.             return 0
  7842.             ;;
  7843.         -@(s|-physicalextentsize))
  7844.             _sizes
  7845.             return 0
  7846.             ;;
  7847.     esac
  7848.  
  7849.     if [[ "$cur" == -* ]]; then
  7850.         COMPREPLY=( $( compgen -W '-A --autobackup --addtag \
  7851.             --alloc -d --debug -h --help -l --maxlogicalvolumes \
  7852.             -M --metadatatype -p --maxphysicalvolumes -s \
  7853.             --physicalextentsize -t --test -v --verbose \
  7854.             --version' -- $cur ) )
  7855.     else
  7856.         _args
  7857.         if [ $args -eq 0 ]; then
  7858.             _volumegroups
  7859.         else
  7860.             _physicalvolumes
  7861.         fi
  7862.     fi
  7863. }
  7864. complete -F _vgcreate vgcreate
  7865.  
  7866. _vgremove()
  7867. {
  7868.     local cur
  7869.  
  7870.     COMPREPLY=()
  7871.     cur=`_get_cword`
  7872.  
  7873.     if [[ "$cur" == -* ]]; then
  7874.         COMPREPLY=( $( compgen -W '-d --debug -h --help -t --test \
  7875.         -v --verbose --version' -- $cur ) )
  7876.     else
  7877.         _volumegroups
  7878.     fi
  7879. }
  7880. complete -F _vgremove vgremove
  7881.  
  7882. _vgrename()
  7883. {
  7884.     local cur prev
  7885.  
  7886.     COMPREPLY=()
  7887.     cur=`_get_cword`
  7888.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7889.  
  7890.     case "$prev" in
  7891.         -@(A|-autobackup))
  7892.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  7893.             return 0
  7894.             ;;
  7895.     esac
  7896.  
  7897.     if [[ "$cur" == -* ]]; then
  7898.         COMPREPLY=( $( compgen -W '-A --autobackup -d --debug -h \
  7899.             -? --help -t --test -v --verbose --version' -- $cur ) )
  7900.     else
  7901.         _volumegroups
  7902.     fi
  7903. }
  7904. complete -F _vgrename vgrename
  7905.  
  7906. _vgreduce()
  7907. {
  7908.     local cur prev
  7909.  
  7910.     COMPREPLY=()
  7911.     cur=`_get_cword`
  7912.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7913.  
  7914.     case "$prev" in
  7915.         -@(A|-autobackup))
  7916.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  7917.             return 0
  7918.             ;;
  7919.     esac
  7920.  
  7921.     if [[ "$cur" == -* ]]; then
  7922.         COMPREPLY=( $( compgen -W '-a --all -A --autobackup -d \
  7923.             --debug -h --help --removemissing -t --test -v \
  7924.             --verbose --version' -- $cur ) )
  7925.  
  7926.     else
  7927.         _args
  7928.         if [ $args -eq 0 ]; then
  7929.             _volumegroups
  7930.         else
  7931.             _physicalvolumes
  7932.         fi
  7933.     fi
  7934. }
  7935. complete -F _vgreduce vgreduce
  7936.  
  7937. _vgextend()
  7938. {
  7939.     local cur prev
  7940.  
  7941.     COMPREPLY=()
  7942.     cur=`_get_cword`
  7943.     prev=${COMP_WORDS[COMP_CWORD-1]}
  7944.  
  7945.     case "$prev" in
  7946.         -@(A|-autobackup))
  7947.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  7948.             return 0
  7949.             ;;
  7950.         -@(L|-size))
  7951.             _sizes
  7952.             return 0
  7953.             ;;
  7954.     esac
  7955.  
  7956.     if [[ "$cur" == -* ]]; then
  7957.         COMPREPLY=( $( compgen -W '-A --autobackup -d --debug -h \
  7958.             -? --help -t --test -v --verbose --version' -- $cur ) )
  7959.     else
  7960.         _args
  7961.         if [ $args -eq 0 ]; then
  7962.             _volumegroups
  7963.         else
  7964.             _physicalvolumes
  7965.         fi
  7966.     fi
  7967. }
  7968. complete -F _vgextend vgextend
  7969.  
  7970. _vgport()
  7971. {
  7972.     local cur prev
  7973.  
  7974.     COMPREPLY=()
  7975.     cur=`_get_cword`
  7976.  
  7977.     if [[ "$cur" == -* ]]; then
  7978.         COMPREPLY=( $( compgen -W '-a --all -d --debug -h \
  7979.             -? --help -v --verbose --version' -- $cur ) )
  7980.     else
  7981.         _volumegroups
  7982.     fi
  7983. }
  7984. complete -F _vgport vgimport vgexport
  7985.  
  7986. _vgck()
  7987. {
  7988.     local cur prev
  7989.  
  7990.     COMPREPLY=()
  7991.     cur=`_get_cword`
  7992.  
  7993.     if [[ "$cur" == -* ]]; then
  7994.         COMPREPLY=( $( compgen -W '-d --debug -h \
  7995.             -? --help -v --verbose --version' -- $cur ) )
  7996.     else
  7997.         _volumegroups
  7998.     fi
  7999. }
  8000. complete -F _vgck vgck
  8001.  
  8002. _vgconvert()
  8003. {
  8004.     local cur prev
  8005.  
  8006.     COMPREPLY=()
  8007.     cur=`_get_cword`
  8008.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8009.  
  8010.     case "$prev" in
  8011.         -@(M|-metadatatype))
  8012.             COMPREPLY=( $( compgen -W '1 2' -- $cur ) )
  8013.             return 0
  8014.             ;;
  8015.         --metadatacopies)
  8016.             COMPREPLY=( $( compgen -W '0 1 2' -- $cur ) )
  8017.             return 0
  8018.             ;;
  8019.         --metadatasize)
  8020.             _sizes
  8021.             return 0
  8022.             ;;
  8023.     esac
  8024.  
  8025.     if [[ "$cur" == -* ]]; then
  8026.         COMPREPLY=( $( compgen -W '-d --debug -h --help --labelsector \
  8027.             -M --metadatatype --metadatacopies --metadatasize \
  8028.             -t --test -v --verbose --version' -- $cur ) )
  8029.     else
  8030.         _volumegroups
  8031.     fi
  8032. }
  8033. complete -F _vgconvert vgconvert
  8034.  
  8035. _vgcfgbackup()
  8036. {
  8037.     local cur prev
  8038.  
  8039.     COMPREPLY=()
  8040.     cur=`_get_cword`
  8041.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8042.  
  8043.     case "$prev" in
  8044.         -@(f|-file))
  8045.             _filedir
  8046.             return 0
  8047.             ;;
  8048.     esac
  8049.  
  8050.     if [[ "$cur" == -* ]]; then
  8051.         COMPREPLY=( $( compgen -W '-d --debug -f --file -h --help \
  8052.             --ignorelockingfailure -P --partial -v --verbose \
  8053.             --version' -- $cur ) )
  8054.     else
  8055.         _volumegroups
  8056.     fi
  8057. }
  8058. complete -F _vgcfgbackup vgcfgbackup
  8059.  
  8060. _vgcfgrestore()
  8061. {
  8062.     local cur prev
  8063.  
  8064.     COMPREPLY=()
  8065.     cur=`_get_cword`
  8066.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8067.  
  8068.     case "$prev" in
  8069.         -@(f|-file))
  8070.             _filedir
  8071.             return 0
  8072.             ;;
  8073.         -@(M|-metadatatype))
  8074.             COMPREPLY=( $( compgen -W '1 2' -- $cur ) )
  8075.             return 0
  8076.             ;;
  8077.         -@(n|-name))
  8078.             _volumegroups
  8079.             return 0
  8080.             ;;
  8081.     esac
  8082.  
  8083.     if [[ "$cur" == -* ]]; then
  8084.         COMPREPLY=( $( compgen -W '-d --debug -f --file -l --list \
  8085.             -h --help -M --Metadatatype -n --name -t --test \
  8086.             -v --verbose --version' -- $cur ) )
  8087.     else
  8088.         _volumegroups
  8089.     fi
  8090. }
  8091. complete -F _vgcfgrestore vgcfgrestore
  8092.  
  8093. _vgmerge()
  8094. {
  8095.     local cur prev
  8096.  
  8097.     COMPREPLY=()
  8098.     cur=`_get_cword`
  8099.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8100.  
  8101.     case "$prev" in
  8102.         -@(A|-autobackup))
  8103.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  8104.             return 0
  8105.             ;;
  8106.     esac
  8107.  
  8108.     if [[ "$cur" == -* ]]; then
  8109.         COMPREPLY=( $( compgen -W '-A --autobackup -d --debug \
  8110.             -h --help -l --list -t --test -v --verbose \
  8111.             --version' -- $cur ) )
  8112.     else
  8113.         _volumegroups
  8114.     fi
  8115. }
  8116. complete -F _vgmerge vgmerge
  8117.  
  8118. _vgsplit()
  8119. {
  8120.     local cur prev
  8121.  
  8122.     COMPREPLY=()
  8123.     cur=`_get_cword`
  8124.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8125.  
  8126.     case "$prev" in
  8127.         -@(A|-autobackup))
  8128.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  8129.             return 0
  8130.             ;;
  8131.         -@(M|-metadatatype))
  8132.             COMPREPLY=( $( compgen -W '1 2' -- $cur ) )
  8133.             return 0
  8134.             ;;
  8135.     esac
  8136.  
  8137.     if [[ "$cur" == -* ]]; then
  8138.         COMPREPLY=( $( compgen -W '-A --autobackup -d --debug \
  8139.             -h --help -l --list -M --metadatatype -t --test \
  8140.             -v --verbose --version' -- $cur ) )
  8141.     else
  8142.         _args
  8143.         if [ $args -eq 0 -o $args -eq 1 ]; then
  8144.             _volumegroups
  8145.         else
  8146.             _physicalvolumes
  8147.         fi
  8148.     fi
  8149. }
  8150. complete -F _vgsplit vgsplit
  8151.  
  8152. _vgmknodes()
  8153. {
  8154.     local cur
  8155.  
  8156.     COMPREPLY=()
  8157.     cur=`_get_cword`
  8158.  
  8159.     if [[ "$cur" == -* ]]; then
  8160.         COMPREPLY=( $( compgen -W '-d --debug -h --help -v --verbose \
  8161.             --version' -- $cur ) )
  8162.     else
  8163.         _volumegroups
  8164.     fi
  8165. }
  8166. complete -F _vgmknodes vgmknodes
  8167.  
  8168. _lvscan()
  8169. {
  8170.     local cur
  8171.  
  8172.     COMPREPLY=()
  8173.     cur=`_get_cword`
  8174.  
  8175.     if [[ "$cur" == -* ]]; then
  8176.         COMPREPLY=( $( compgen -W '-b --blockdevice -d --debug \
  8177.             -h -? --help --ignorelockingfailure -P \
  8178.             --partial -v --verbose --version' -- $cur ) )
  8179.     fi
  8180. }
  8181. complete -F _lvscan lvscan
  8182.  
  8183. _lvs()
  8184. {
  8185.     local cur prev
  8186.  
  8187.     COMPREPLY=()
  8188.     cur=`_get_cword`
  8189.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8190.  
  8191.     case "$prev" in
  8192.         -@(o|O|-options|-sort))
  8193.             COMPREPLY=( $( compgen -W 'lv_uuid lv_name \
  8194.                 lv_attr lv_minor lv_size seg_count \
  8195.                 origin snap_percent segtype stripes \
  8196.                 stripesize chunksize seg_start \
  8197.                 seg_size' -- $cur ) )
  8198.             return 0
  8199.             ;;
  8200.         --units)
  8201.             _units
  8202.             return 0
  8203.             ;;
  8204.     esac
  8205.  
  8206.     if [[ "$cur" == -* ]]; then
  8207.         COMPREPLY=( $( compgen -W '--aligned -d --debug \
  8208.             -h --help --ignorelockingfailure --noheadings \
  8209.             --nosuffix -o --options -O --sort -P --partial \
  8210.             --segments --separator --unbuffered --units \
  8211.             -v --verbose --version' -- $cur ) )
  8212.     else
  8213.         _logicalvolumes
  8214.     fi
  8215. }
  8216. complete -F _lvs lvs
  8217.  
  8218. _lvdisplay()
  8219. {
  8220.     local cur prev
  8221.  
  8222.     COMPREPLY=()
  8223.     cur=`_get_cword`
  8224.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8225.  
  8226.     case "$prev" in
  8227.         --units)
  8228.             _units
  8229.             return 0
  8230.             ;;
  8231.     esac
  8232.  
  8233.     if [[ "$cur" == -* ]]; then
  8234.         COMPREPLY=( $( compgen -W '-c --colon -C --columns --units \
  8235.             -P --partial -m --maps -v --verbose -d --debug -h \
  8236.             --help --version' -- $cur ) )
  8237.     else
  8238.         _logicalvolumes
  8239.     fi
  8240. }
  8241. complete -F _lvdisplay lvdisplay
  8242.  
  8243. _lvchange()
  8244. {
  8245.     local cur prev
  8246.  
  8247.     COMPREPLY=()
  8248.     cur=`_get_cword`
  8249.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8250.  
  8251.     case "$prev" in
  8252.         -@(a|A|C|M|-available|-autobackup|-continguous|-persistent))
  8253.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  8254.             return 0
  8255.             ;;
  8256.         -@(p|-permission))
  8257.             COMPREPLY=( $( compgen -W 'r rw' -- $cur ) )
  8258.             return 0
  8259.             ;;
  8260.     esac
  8261.  
  8262.     if [[ "$cur" == -* ]]; then
  8263.         COMPREPLY=( $( compgen -W '-A --autobackup -a --available \
  8264.             --addtag --alloc -C --contiguous -d --debug --deltag \
  8265.             -f --force -h --help --ignorelockingfailure -M \
  8266.             --persistent --major major --minor minor -P --partial \
  8267.             -p --permission -r --readahead --refresh -t --test \
  8268.             -v --verbose --version' -- $cur ) )
  8269.     else
  8270.         _logicalvolumes
  8271.     fi
  8272. }
  8273. complete -F _lvchange lvchange
  8274.  
  8275. _lvcreate()
  8276. {
  8277.     local cur prev
  8278.  
  8279.     COMPREPLY=()
  8280.     cur=`_get_cword`
  8281.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8282.  
  8283.     case "$prev" in
  8284.         -@(A|C|M|Z|-autobackup|-continguous|-persistent|-zero))
  8285.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  8286.             return 0
  8287.             ;;
  8288.         -@(L|-size))
  8289.             _sizes
  8290.             return 0
  8291.             ;;
  8292.         -@(p|-permission))
  8293.             COMPREPLY=( $( compgen -W 'r rw' -- $cur ) )
  8294.             return 0
  8295.             ;;
  8296.         -@(n|-name))
  8297.             _logicalvolumes
  8298.             return 0
  8299.             ;;
  8300.     esac
  8301.  
  8302.     if [[ "$cur" == -* ]]; then
  8303.         COMPREPLY=( $( compgen -W '-A --autobackup --addtag --alloc \
  8304.             -C --contiguous -d --debug -h -? --help -i --stripes \
  8305.             -I --stripesize -l --extents -L --size -M --persistent \
  8306.             --major --minor -n --name -p --permission -r \
  8307.             --readahead -t --test --type -v --verbose -Z --zero \
  8308.             --version' -- $cur ) )
  8309.     else
  8310.         _args
  8311.         if [ $args -eq 0 ]; then
  8312.             _volumegroups
  8313.         else
  8314.             _physicalvolumes
  8315.         fi
  8316.     fi
  8317. }
  8318. complete -F _lvcreate lvcreate
  8319.  
  8320. _lvremove()
  8321. {
  8322.     local cur prev
  8323.  
  8324.     COMPREPLY=()
  8325.     cur=`_get_cword`
  8326.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8327.  
  8328.     case "$prev" in
  8329.         -@(A|-autobackup))
  8330.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  8331.             return 0
  8332.             ;;
  8333.     esac
  8334.  
  8335.     if [[ "$cur" == -* ]]; then
  8336.         COMPREPLY=( $( compgen -W '-A --autobackup -d --debug -f \
  8337.             --force -h -?  --help -t --test -v --verbose \
  8338.             --version' -- $cur ) )
  8339.     else
  8340.         _logicalvolumes
  8341.     fi
  8342. }
  8343. complete -F _lvremove lvremove
  8344.  
  8345. _lvrename()
  8346. {
  8347.     local cur prev
  8348.  
  8349.     COMPREPLY=()
  8350.     cur=`_get_cword`
  8351.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8352.  
  8353.     case "$prev" in
  8354.         -@(A|-autobackup))
  8355.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  8356.             return 0
  8357.             ;;
  8358.     esac
  8359.  
  8360.     if [[ "$cur" == -* ]]; then
  8361.         COMPREPLY=( $( compgen -W '-A --autobackup -d --debug -h \
  8362.             -? --help -t --test -v --verbose --version' -- $cur ) )
  8363.     else
  8364.         _logicalvolumes
  8365.     fi
  8366. }
  8367. complete -F _lvrename lvrename
  8368.  
  8369. _lvreduce()
  8370. {
  8371.     local cur prev
  8372.  
  8373.     COMPREPLY=()
  8374.     cur=`_get_cword`
  8375.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8376.  
  8377.     case "$prev" in
  8378.         -@(A|-autobackup))
  8379.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  8380.             return 0
  8381.             ;;
  8382.         -@(L|-size))
  8383.             _sizes
  8384.             return 0
  8385.             ;;
  8386.     esac
  8387.  
  8388.     if [[ "$cur" == -* ]]; then
  8389.         COMPREPLY=( $( compgen -W '-A --autobackup -d \
  8390.             --debug -f --force -h --help -l --extents \
  8391.             -L --size -n --nofsck -r --resizefs -t --test \
  8392.             -v --verbose --version' -- $cur ) )
  8393.     else
  8394.         _logicalvolumes
  8395.     fi
  8396. }
  8397. complete -F _lvreduce lvreduce
  8398.  
  8399. _lvresize()
  8400. {
  8401.     local cur prev
  8402.  
  8403.     COMPREPLY=()
  8404.     cur=`_get_cword`
  8405.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8406.  
  8407.     case "$prev" in
  8408.         -@(A|-autobackup))
  8409.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  8410.             return 0
  8411.             ;;
  8412.         -@(L|-size))
  8413.             _sizes
  8414.             return 0
  8415.             ;;
  8416.     esac
  8417.  
  8418.     if [[ "$cur" == -* ]]; then
  8419.         COMPREPLY=( $( compgen -W '-A --autobackup --alloc -d \
  8420.             --debug -h --help -i --stripes -I --stripesize \
  8421.             -l --extents -L --size -n --nofsck -r --resizefs \
  8422.             -t --test --type -v --verbose --version' -- $cur ) )
  8423.     else
  8424.         _args
  8425.         if [ $args -eq 0 ]; then
  8426.             _logicalvolumes
  8427.         else
  8428.             _physicalvolumes
  8429.         fi
  8430.     fi
  8431. }
  8432. complete -F _lvresize lvresize
  8433.  
  8434. _lvextend()
  8435. {
  8436.     local cur prev
  8437.  
  8438.     COMPREPLY=()
  8439.     cur=`_get_cword`
  8440.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8441.  
  8442.     case "$prev" in
  8443.         -@(A|-autobackup))
  8444.             COMPREPLY=( $( compgen -W 'y n' -- $cur ) )
  8445.             return 0
  8446.             ;;
  8447.         -@(L|-size))
  8448.             _sizes
  8449.             return 0
  8450.             ;;
  8451.     esac
  8452.  
  8453.     if [[ "$cur" == -* ]]; then
  8454.         COMPREPLY=( $( compgen -W '-A --autobackup --alloc -d \
  8455.             --debug -h --help -i --stripes -I --stripesize \
  8456.             -l --extents -L --size -n --nofsck -r --resizefs \
  8457.             -t --test --type -v --verbose --version' -- $cur ) )
  8458.     else
  8459.         _args
  8460.         if [ $args -eq 0 ]; then
  8461.             _logicalvolumes
  8462.         else
  8463.             _physicalvolumes
  8464.         fi
  8465.     fi
  8466. }
  8467. complete -F _lvextend lvextend
  8468.  
  8469. _lvm()
  8470. {
  8471.     local prev
  8472.  
  8473.     COMPREPLY=()
  8474.     cur=`_get_cword`
  8475.  
  8476.     if [ $COMP_CWORD -eq 1 ]; then
  8477.         COMPREPLY=( $( compgen -W 'dumpconfig help lvchange \
  8478.             lvcreate lvdisplay lvextend lvmchange \
  8479.             lvmdiskscan lvmsadc lvmsar lvreduce \
  8480.             lvremove lvrename lvresize lvs lvscan \
  8481.             pvchange pvcreate pvdata pvdisplay pvmove \
  8482.             pvremove pvresize pvs pvscan vgcfgbackup \
  8483.             vgcfgrestore vgchange vgck vgconvert \
  8484.             vgcreate vgdisplay vgexport vgextend \
  8485.             vgimport vgmerge vgmknodes vgreduce \
  8486.             vgremove vgrename vgs vgscan vgsplit \
  8487.             version' -- $cur ) )
  8488.     else
  8489.         case ${COMP_WORDS[1]} in
  8490.             pvchange)
  8491.                 _pvchange
  8492.                 ;;
  8493.             pvcreate)
  8494.                 _pvcreate
  8495.                 ;;
  8496.             pvdisplay)
  8497.                 _pvdisplay
  8498.                 ;;
  8499.             pvmove)
  8500.                 _pvmove
  8501.                 ;;
  8502.             pvremove)
  8503.                 _pvremove
  8504.                 ;;
  8505.             pvresize)
  8506.                 _pvresize
  8507.                 ;;
  8508.             pvs)
  8509.                 _pvs
  8510.                 ;;
  8511.             pvscan)
  8512.                 _pvscan
  8513.                 ;;
  8514.             vgcfgbackup)
  8515.                 _vgcfgbackup
  8516.                 ;;
  8517.             vgcfgrestore)
  8518.                 _vgcfgrestore
  8519.                 ;;
  8520.             vgchange)
  8521.                 _vgchange
  8522.                 ;;
  8523.             vgck)
  8524.                 _vgck
  8525.                 ;;
  8526.             vgconvert)
  8527.                 _vgconvert
  8528.                 ;;
  8529.             vgcreate)
  8530.                 _vgcreate
  8531.                 ;;
  8532.             vgdisplay)
  8533.                 _vgdisplay
  8534.                 ;;
  8535.             vgexport)
  8536.                 _vgexport
  8537.                 ;;
  8538.             vgextend)
  8539.                 _vgextend
  8540.                 ;;
  8541.             vgimport)
  8542.                 _vgimport
  8543.                 ;;
  8544.             vgmerge)
  8545.                 _vgmerge
  8546.                 ;;
  8547.             vgmknodes)
  8548.                 _vgmknodes
  8549.                 ;;
  8550.             vgreduce)
  8551.                 _vgreduce
  8552.                 ;;
  8553.             vgremove)
  8554.                 _vgremove
  8555.                 ;;
  8556.             vgrename)
  8557.                 _vgrename
  8558.                 ;;
  8559.             vgs)
  8560.                 _vgs
  8561.                 ;;
  8562.             vgscan)
  8563.                 _vgscan
  8564.                 ;;
  8565.             vgsplit)
  8566.                 _vgsplit
  8567.                 ;;
  8568.             lvchange)
  8569.                 _lvchange
  8570.                 ;;
  8571.             lvcreate)
  8572.                 _lvcreate
  8573.                 ;;
  8574.             lvdisplay)
  8575.                 _lvdisplay
  8576.                 ;;
  8577.             lvextend)
  8578.                 _lvextend
  8579.                 ;;
  8580.             lvreduce)
  8581.                 _lvreduce
  8582.                 ;;
  8583.             lvremove)
  8584.                 _lvremove
  8585.                 ;;
  8586.             lvrename)
  8587.                 _lvrename
  8588.                 ;;
  8589.             lvresize)
  8590.                 _lvresize
  8591.                 ;;
  8592.             lvs)
  8593.                 _lvs
  8594.                 ;;
  8595.             lvscan)
  8596.                 _lvscan
  8597.                 ;;
  8598.         esac
  8599.     fi
  8600. }
  8601. complete -F _lvm lvm
  8602. }
  8603.  
  8604. # mkinitrd(8) completion
  8605. #
  8606. have mkinitrd &&
  8607. _mkinitrd()
  8608. {
  8609.     local cur args
  8610.  
  8611.     COMPREPLY=()
  8612.     cur=`_get_cword`
  8613.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8614.  
  8615.     # --name value style option
  8616.     case "$prev" in
  8617.         --preload)
  8618.             _modules
  8619.             return 0
  8620.             ;;
  8621.     esac
  8622.  
  8623.     # --name=value style option
  8624.     if [[ "$cur" == *=* ]]; then
  8625.         prev=${cur/=*/}
  8626.         cur=${cur/*=/}
  8627.         case "$prev" in
  8628.             --@(with|builtin))
  8629.                 _modules
  8630.                 return 0
  8631.                 ;;
  8632.             --@(fstab|dsdt))
  8633.                 _filedir
  8634.                 return 0
  8635.                 ;;
  8636.             --tmpdir)
  8637.                 _filedir -d
  8638.                 return 0
  8639.                 ;;
  8640.         esac
  8641.     fi
  8642.  
  8643.  
  8644.     if [[ "$cur" == -* ]]; then
  8645.         COMPREPLY=( $( compgen -W '--version -v -f --preload \
  8646.             --with= --omit-scsi-modules --omit-raid-modules \
  8647.             --images-version --fstab= --nocompress --builtin= \
  8648.             --nopivot --noudev --allow-missing --tmpdir= \
  8649.             --initrdfs= --dsdt= --lvm-version= --froce-usb' \
  8650.             -- $cur ) )
  8651.     else
  8652.         _count_args
  8653.  
  8654.         case $args in
  8655.             1)
  8656.                 _filedir
  8657.                 ;;
  8658.             2)
  8659.                 COMPREPLY=( $( command ls /lib/modules | grep "^$cur" ) )
  8660.                 ;;
  8661.         esac
  8662.     fi
  8663.  
  8664. } &&
  8665. complete -F _mkinitrd mkinitrd
  8666.  
  8667. # pkgconfig(1) completion
  8668. #
  8669. have pkg-config &&
  8670. _pkg_config()
  8671. {
  8672.     local cur
  8673.  
  8674.     COMPREPLY=()
  8675.     cur=`_get_cword`
  8676.  
  8677.     if [[ "$cur" == -* ]]; then
  8678.         # return list of available options
  8679.         COMPREPLY=( $( compgen -W '-version --modversion \
  8680.               --atleast-pkgconfig-version= --libs --libs-only-l \
  8681.               --libs-only-other --libs-only-L --cflags \
  8682.               --cflags-only-I --cflags-only-other --variable= \
  8683.               --define-variable= --exists --uninstalled \
  8684.               --atleast-version= --exact-version= --max-version= \
  8685.               --list-all --debug --print-errors --silence-errors \
  8686.               --errors-to-stdout -? --help --usage' -- $cur))
  8687.     else
  8688.         COMPREPLY=( $( pkg-config --list-all 2>/dev/null | \
  8689.                     awk '{print $1}' | grep "^$cur" ) )
  8690.     fi
  8691. } &&
  8692. complete -F _pkg_config pkg-config
  8693.  
  8694.  
  8695. # cpio(1) completion
  8696. #
  8697. have cpio && {
  8698. _cpio_format()
  8699. {
  8700.     COMPREPLY=( $( compgen -W 'bin odc newc crc tar ustar hpbin hpodc' -- $cur ) )
  8701. }
  8702.  
  8703. _cpio()
  8704. {
  8705.     local cur
  8706.  
  8707.     COMPREPLY=()
  8708.     cur=`_get_cword`
  8709.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8710.  
  8711.     # --name value style option
  8712.     case $prev in
  8713.         -H)
  8714.             _cpio_format
  8715.             return 0
  8716.             ;;
  8717.         -@(E|F|I))
  8718.             _filedir
  8719.             return 0
  8720.             ;;
  8721.         -R)
  8722.             _usergroup
  8723.             return 0
  8724.             ;;
  8725.     esac
  8726.  
  8727.     # --name=value style option
  8728.     if [[ "$cur" == *=* ]]; then
  8729.         prev=${cur/=*/}
  8730.         cur=${cur/*=/}
  8731.         case $prev in
  8732.             --format)
  8733.                 _cpio_format
  8734.                 return 0
  8735.                 ;;
  8736.             --@(file|pattern-file))
  8737.                 _filedir
  8738.                 return 0
  8739.                 ;;
  8740.             --owner)
  8741.                 _usergroup
  8742.                 return 0
  8743.                 ;;
  8744.             --rsh-command)
  8745.                 COMPREPLY=( $( compgen -c -- $cur ) )
  8746.                 return 0
  8747.                 ;;
  8748.         esac
  8749.     fi
  8750.  
  8751.     if [ $COMP_CWORD -eq 1 ]; then
  8752.         COMPREPLY=( $( compgen -W '-o --create -i --extract -p --pass-through' -- $cur) )
  8753.     else
  8754.         case ${COMP_WORDS[1]} in
  8755.             -@(o|-create))
  8756.                 if [[ "$cur" == -* ]]; then
  8757.                     COMPREPLY=( $( compgen -W '-0 -a -c -v -A -B\
  8758.                         -L -V -C -H -M -O -F --file= --format=\
  8759.                         --message= --null --reset-access-time\
  8760.                         --verbose --dot --append --block-size=\
  8761.                         --dereference --io-size= --quiet\
  8762.                         --force-local --rsh-command= --help\
  8763.                         --version' -- $cur ) )
  8764.                 fi
  8765.                 ;;
  8766.             -@(i|-extract))
  8767.                 if [[ "$cur" == -* ]]; then
  8768.                     COMPREPLY=( $( compgen -W '-b -c -d -f -m -n -r\
  8769.                         -t -s -u -v -B -S -V -C -E -H -M -R -I\
  8770.                         -F --file= --make-directories\
  8771.                         --nonmatching\
  8772.                         --preserve-modification-time\
  8773.                         --numeric-uid-gid --rename -t --list\
  8774.                         --swap-bytes --swap --dot\
  8775.                         --unconditional --verbose --block-size=\
  8776.                         --swap-halfwords --io-size=\
  8777.                         --pattern-file= --format= --owner=\
  8778.                         --no-preserve-owner --message=\
  8779.                         --force-local --no-absolute-filenames\
  8780.                         --sparse --only-verify-crc --quiet\
  8781.                         --rsh-command= --help\
  8782.                         --version' -- $cur ) )
  8783.                 fi
  8784.                 ;;
  8785.             -@(p|-pass-through))
  8786.                 if [[ "$cur" == -* ]]; then
  8787.                     COMPREPLY=( $( compgen -W '-0 -a -d -l -m -u -v\
  8788.                         -L -V -R --null --reset-access-time\
  8789.                         --make-directories --link --quiet\
  8790.                         --preserve-modification-time\
  8791.                         --unconditional --verbose --dot\
  8792.                         --dereference --owner=\
  8793.                         --no-preserve-owner --sparse --help\
  8794.                         --version' -- $cur ) )
  8795.                 else
  8796.                     _filedir -d
  8797.                 fi
  8798.                 ;;
  8799.         esac
  8800.     fi
  8801. }
  8802. complete -F _cpio cpio
  8803. }
  8804.  
  8805. # id(1) completion
  8806. #
  8807. have id &&
  8808. _id()
  8809. {
  8810.     local cur
  8811.  
  8812.     COMPREPLY=()
  8813.     cur=`_get_cword`
  8814.  
  8815.     if [[ "$cur" == -* ]]; then
  8816.         COMPREPLY=( $( compgen -W '-a -g --group -G --groups -n --name\
  8817.             -r --real -u --user --help --version' -- $cur ) )
  8818.     else
  8819.         COMPREPLY=( $( compgen -u $cur  ) )
  8820.     fi
  8821. } &&
  8822. complete -F _id id
  8823.  
  8824. # getent(1) completion
  8825. #
  8826. have getent &&
  8827. _getent()
  8828. {
  8829.     local cur prev
  8830.  
  8831.     COMPREPLY=()
  8832.     cur=`_get_cword`
  8833.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8834.  
  8835.     case $prev in
  8836.         passwd)
  8837.             COMPREPLY=( $( compgen -u $cur  ) )
  8838.             return 0
  8839.             ;;
  8840.         group)
  8841.             COMPREPLY=( $( compgen -g $cur  ) )
  8842.             return 0
  8843.             ;;
  8844.         services)
  8845.             COMPREPLY=( $( compgen -s $cur  ) )
  8846.             return 0
  8847.             ;;
  8848.         hosts)
  8849.             COMPREPLY=( $( compgen -A hostname $cur  ) )
  8850.             return 0
  8851.             ;;
  8852.         protocols|networks|ahosts|ahostsv4|ahostsv6|rpc)
  8853.             COMPREPLY=( $( getent $prev | \
  8854.                 sed -ne 's|^\('$cur'[^[:space:]]*\).*|\1|p' ) )
  8855.             return 0
  8856.             ;;
  8857.         aliases|shadow)
  8858.             COMPREPLY=( $( getent $prev | \
  8859.                 sed -ne 's|^\('$cur'[^:]*\).*|\1|p' ) )
  8860.             return 0
  8861.             ;;
  8862.     esac
  8863.  
  8864.  
  8865.     if [ $COMP_CWORD -eq 1 ]; then
  8866.         COMPREPLY=( $( compgen -W 'passwd group hosts services \
  8867.                        protocols networks ahosts ahostsv4 \
  8868.                        ahostsv6 aliases ethers netgroup \
  8869.                        rpc shadow' -- $cur ) )
  8870.     fi
  8871. } &&
  8872. complete -F _getent getent
  8873.  
  8874. # ntpdate(1) completion
  8875. #
  8876. have ntpdate &&
  8877. _ntpdate()
  8878. {
  8879.     local cur prev
  8880.  
  8881.     COMPREPLY=()
  8882.     cur=`_get_cword`
  8883.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8884.  
  8885.     case $prev in
  8886.         -k)
  8887.             _filedir
  8888.             return 0
  8889.             ;;
  8890.         -U)
  8891.             COMPREPLY=( $( compgen -u $cur  ) )
  8892.             return 0
  8893.             ;;
  8894.     esac
  8895.  
  8896.     if [[ "$cur" == -* ]]; then
  8897.         COMPREPLY=( $( compgen -W '-4 -6 -b -B -d -Q -q -s -u -v -a\
  8898.             -e -k -p -o -r -t' -- $cur ) )
  8899.     else
  8900.         _known_hosts
  8901.     fi
  8902. } &&
  8903. complete -F _ntpdate ntpdate
  8904.  
  8905. # smartctl(8) completion
  8906. #
  8907. have smartctl && {
  8908. _smartctl_quietmode()
  8909. {
  8910.     COMPREPLY=( $( compgen -W 'errorsonly silent' -- $cur ) )
  8911. }
  8912. _smartctl_device()
  8913. {
  8914.     COMPREPLY=( $( compgen -W 'ata scsi 3ware' -- $cur ) )
  8915. }
  8916. _smartctl_tolerance()
  8917. {
  8918.     COMPREPLY=( $( compgen -W 'warn exit ignore' -- $cur ) )
  8919. }
  8920. _smartctl_badsum()
  8921. {
  8922.     COMPREPLY=( $( compgen -W 'normal conservative permissive verypermissive' -- $cur ) )
  8923. }
  8924. _smartctl_report()
  8925. {
  8926.     COMPREPLY=( $( compgen -W 'ioctl ataioctl scsiioctl' -- $cur ) )
  8927. }
  8928. _smartctl_feature()
  8929. {
  8930.     COMPREPLY=( $( compgen -W 'on off' -- $cur ) )
  8931. }
  8932. _smartctl_log()
  8933. {
  8934.     COMPREPLY=( $( compgen -W 'error selftest selective directory' -- $cur ) )
  8935. }
  8936. _smartctl_vendorattribute()
  8937. {
  8938.     COMPREPLY=( $( compgen -W 'help 9,minutes 9,seconds 9,halfminutes \
  8939.         9,temp 192,emergencyretractcyclect 193,loadunload \
  8940.         194,10xCelsius 194,unknown 198,offlinescanuncsectorct \
  8941.         200,writeerrorcount 201,detectedtacount 220,temp' -- $cur ) )
  8942. }
  8943. _smartctl_firmwarebug()
  8944. {
  8945.     COMPREPLY=( $( compgen -W 'none samsung samsung2' -- $cur ) )
  8946. }
  8947. _smartctl_presets()
  8948. {
  8949.     COMPREPLY=( $( compgen -W 'use ignore show showall' -- $cur ) )
  8950. }
  8951. _smartctl_test()
  8952. {
  8953.     COMPREPLY=( $( compgen -W 'offline short long conveyance select afterselect,on afterselect,off pending' -- $cur ) )
  8954. }
  8955.  
  8956. _smartctl()
  8957. {
  8958.     local cur prev
  8959.  
  8960.     COMPREPLY=()
  8961.     cur=`_get_cword`
  8962.     prev=${COMP_WORDS[COMP_CWORD-1]}
  8963.  
  8964.     # --name value style option
  8965.     case "$prev" in
  8966.         -q)
  8967.             _smartctl_quietmode
  8968.             ;;
  8969.         -d)
  8970.             _smartctl_device
  8971.             return 0
  8972.             ;;
  8973.         -t)
  8974.             _smartctl_tolerance
  8975.             return 0
  8976.             ;;
  8977.         -b)
  8978.             _smartctl_badsum
  8979.             return 0
  8980.             ;;
  8981.         -r)
  8982.             _smartctl_report
  8983.             return 0
  8984.             ;;
  8985.         -s)
  8986.             _smartctl_feature
  8987.             return 0
  8988.             ;;
  8989.         -o)
  8990.             _smartctl_feature
  8991.             return 0
  8992.             ;;
  8993.         -S)
  8994.             _smartctl_feature
  8995.             return 0
  8996.             ;;
  8997.         -l)
  8998.             _smartctl_log
  8999.             return 0
  9000.             ;;
  9001.         -v)
  9002.             _smartctl_vendorattribute
  9003.             return 0
  9004.             ;;
  9005.         -F)
  9006.             _smartctl_firmwarebug
  9007.             return 0
  9008.             ;;
  9009.         -P)
  9010.             _smartctl_presets
  9011.             return 0
  9012.             ;;
  9013.         -t)
  9014.             _smartctl_test
  9015.             return 0
  9016.             ;;
  9017.     esac
  9018.  
  9019.     # --name=value style option
  9020.     if [[ "$cur" == *=* ]]; then
  9021.         prev=${cur/=*/}
  9022.         cur=${cur/*=/}
  9023.         case "$prev" in
  9024.             --quietmode)
  9025.                 _smartctl_quietmode
  9026.                 return 0
  9027.                 ;;
  9028.             --device)
  9029.                 _smartctl_device
  9030.                 return 0
  9031.                 ;;
  9032.             --tolerance)
  9033.                 _smartctl_tolerance
  9034.                 return 0
  9035.                 ;;
  9036.             --badsum)
  9037.                 _smartctl_badsum
  9038.                 return 0
  9039.                 ;;
  9040.             --report)
  9041.                 _smartctl_report
  9042.                 return 0
  9043.                 ;;
  9044.             --smart)
  9045.                 _smartctl_feature
  9046.                 return 0
  9047.                 ;;
  9048.             --offlineauto)
  9049.                 _smartctl_feature
  9050.                 return 0
  9051.                 ;;
  9052.             --saveauto)
  9053.                 _smartctl_feature
  9054.                 return 0
  9055.                 ;;
  9056.             --log)
  9057.                 _smartctl_log
  9058.                 return 0
  9059.                 ;;
  9060.             --vendorattribute)
  9061.                 _smartctl_vendorattribute
  9062.                 return 0
  9063.                 ;;
  9064.             --firmwarebug)
  9065.                 _smartctl_firmwarebug
  9066.                 return 0
  9067.                 ;;
  9068.             --presets)
  9069.                 _smartctl_presets
  9070.                 return 0
  9071.                 ;;
  9072.             --test)
  9073.                 _smartctl_test
  9074.                 return 0
  9075.                 ;;
  9076.         esac
  9077.     fi
  9078.  
  9079.  
  9080.     if [[ "$cur" == -* ]]; then
  9081.         COMPREPLY=( $( compgen -W '-h --help --usage -V --version \
  9082.             --copyright --license-i --info -a --all -q \
  9083.             --quietmode= -d --device= -T --tolerance= -b --badsum= \
  9084.             -r --report= -s --smart= -o --offlineauto= -S \
  9085.             --saveauto= -H --health -c --capabilities -A \
  9086.             --attributes -l --log= -v --vendorattribute= -F \
  9087.             --firmwarebug= -P --presets= -t --test= -C \
  9088.             --captive -X --abort' -- $cur ) )
  9089.     else
  9090.         cur=${cur:=/dev/}
  9091.         _filedir
  9092.     fi
  9093. }
  9094. complete -F _smartctl smartctl
  9095. }
  9096.  
  9097. # sysctl(8) completion
  9098. #
  9099. have sysctl &&
  9100. _sysctl()
  9101. {
  9102.     local cur
  9103.  
  9104.     COMPREPLY=()
  9105.     cur=`_get_cword`
  9106.  
  9107.     COMPREPLY=( $( compgen -W "$(sysctl -N -a 2>/dev/null)" -- $cur ) )
  9108.  
  9109.     return 0
  9110. } &&
  9111. complete -F _sysctl sysctl
  9112.  
  9113. # update-rc.d(8) completion
  9114. #
  9115. # Copyright (C) 2004 Servilio Afre Puentes <servilio@gmail.com>
  9116. #
  9117. have update-rc.d &&
  9118. _update_rc_d()
  9119. {
  9120.     local cur prev sysvdir services options valid_options
  9121.  
  9122.     cur=`_get_cword`
  9123.     prev=${COMP_WORDS[COMP_CWORD-1]}
  9124.  
  9125.     [ -d /etc/rc.d/init.d ] && sysvdir=/etc/rc.d/init.d \
  9126.     || sysvdir=/etc/init.d
  9127.  
  9128.     services=( $(echo $sysvdir/!(README*|*.sh|*.dpkg*|*.rpm@(orig|new|save))) )
  9129.     services=( ${services[@]#$sysvdir/} )
  9130.     options=( -f -n )
  9131.  
  9132.     if [[ $COMP_CWORD -eq 1 || "$prev" == -* ]]; then
  9133.     valid_options=( $( \
  9134.         echo "${COMP_WORDS[@]} ${options[@]}" \
  9135.         | tr " " "\n" \
  9136.         | sed -ne "/$( echo "${options[@]}" | sed "s/ /\\|/g" )/p" \
  9137.         | sort | uniq -u \
  9138.         ) )
  9139.     COMPREPLY=( $( compgen -W '${options[@]} ${services[@]}' \
  9140.         -X '$( echo ${COMP_WORDS[@]} | tr " " "|" )' -- $cur ) )
  9141.     elif [[ "$prev" == ?($( echo ${services[@]} | tr " " "|" )) ]]; then
  9142.     COMPREPLY=( $( compgen -W 'remove defaults start stop' -- $cur ) )
  9143.     elif [[ "$prev" == defaults && "$cur" == [0-9] ]]; then
  9144.     COMPREPLY=( 0 1 2 3 4 5 6 7 8 9 )
  9145.     elif [[ "$prev" == defaults && "$cur" == [sk]?([0-9]) ]]; then
  9146.     COMPREPLY=( 0 1 2 3 4 5 6 7 8 9 )
  9147.     elif [[ "$prev" == defaults && -z "$cur" ]]; then
  9148.     COMPREPLY=( 0 1 2 3 4 5 6 7 8 9 s k )
  9149.     elif [[ "$prev" == ?(start|stop) ]]; then
  9150.     if [[ "$cur" == [0-9] || -z "$cur" ]]; then
  9151.         COMPREPLY=( 0 1 2 3 4 5 6 7 8 9 )
  9152.     elif [[ "$cur" == [0-9][0-9] ]]; then
  9153.         COMPREPLY=( $cur )
  9154.     else
  9155.         COMPREPLY=()
  9156.     fi
  9157.     elif [[ "$prev" == ?([0-9][0-9]|[0-6S]) ]]; then
  9158.     if [[ -z "$cur" ]]; then
  9159.         if [[ $prev == [0-9][0-9] ]]; then
  9160.         COMPREPLY=( 0 1 2 3 4 5 6 S )
  9161.         else
  9162.         COMPREPLY=( 0 1 2 3 4 5 6 S . )
  9163.         fi
  9164.     elif [[ "$cur" == [0-6S.] ]]; then
  9165.         COMPREPLY=( $cur )
  9166.     else
  9167.         COMPREPLY=()
  9168.     fi
  9169.     elif [[ "$prev" == "." ]]; then
  9170.     COMPREPLY=( $(compgen -W "start stop" -- $cur) )
  9171.     else
  9172.     COMPREPLY=()
  9173.     fi
  9174.  
  9175.     return 0
  9176. } &&
  9177. complete -F _update_rc_d update-rc.d
  9178.  
  9179. # invoke-rc.d(8) completion
  9180. #
  9181. # Copyright (C) 2004 Servilio Afre Puentes <servilio@gmail.com>
  9182. #
  9183. have invoke-rc.d &&
  9184. _invoke_rc_d()
  9185. {
  9186.     local cur prev sysvdir services options valid_options
  9187.  
  9188.     cur=`_get_cword`
  9189.     prev=${COMP_WORDS[COMP_CWORD-1]}
  9190.  
  9191.     [ -d /etc/rc.d/init.d ] && sysvdir=/etc/rc.d/init.d \
  9192.     || sysvdir=/etc/init.d
  9193.  
  9194.     services=( $(echo $sysvdir/!(README*|*.sh|*.dpkg*|*.rpm@(orig|new|save))) )
  9195.     services=( ${services[@]#$sysvdir/} )
  9196.     options=( --help --quiet --force --try-anyway --disclose-deny --query --no-fallback )
  9197.  
  9198.     if [[ ($COMP_CWORD -eq 1) || ("$prev" == --* ) ]]; then
  9199.     valid_options=( $( \
  9200.         echo ${COMP_WORDS[@]} ${options[@]} \
  9201.         | tr " " "\n" \
  9202.         | sed -ne "/$( echo ${options[@]} | sed "s/ /\\\\|/g" )/p" \
  9203.         | sort | uniq -u \
  9204.         ) )
  9205.     COMPREPLY=( $( compgen -W '${valid_options[@]} ${services[@]}' -- \
  9206.         $cur ) )
  9207.     elif [ -x $sysvdir/$prev ]; then
  9208.     COMPREPLY=( $( compgen -W '`sed -ne "y/|/ /; \
  9209.                         s/^.*Usage:[ ]*[^ ]*[ ]*{*\([^}\"]*\).*$/\1/p" \
  9210.                         $sysvdir/$prev`' -- \
  9211.         $cur ) )
  9212.     else
  9213.     COMPREPLY=()
  9214.     fi
  9215.  
  9216.     return 0
  9217. } &&
  9218. complete -F _invoke_rc_d invoke-rc.d
  9219.  
  9220. # minicom(1) completion
  9221. #
  9222. have minicom &&
  9223. _minicom()
  9224. {
  9225.     local cur prev
  9226.  
  9227.     COMPREPLY=()
  9228.     cur=`_get_cword`
  9229.     prev=${COMP_WORDS[COMP_CWORD-1]}
  9230.  
  9231.     case $prev in
  9232.         -@(a|c))
  9233.             COMPREPLY=( $( compgen -W 'on off' -- $cur ) )
  9234.             return 0
  9235.             ;;
  9236.         -@(S|C))
  9237.             _filedir
  9238.             return 0
  9239.             ;;
  9240.         -P)
  9241.             COMPREPLY=( $( command ls /dev/tty* ) )
  9242.             COMPREPLY=( $( compgen -W '${COMPREPLY[@]} ${COMPREPLY[@]#/dev/}' -- $cur ) )
  9243.             return 0
  9244.             ;;
  9245.     esac
  9246.  
  9247.  
  9248.     if [[ "$cur" == -* ]]; then
  9249.         COMPREPLY=( $( compgen -W '-s -o -m -M -z -l -L -w -a -t \
  9250.             -c -S -d -p -C -T -8' -- $cur ) )
  9251.     else
  9252.         COMPREPLY=( $( command ls /etc/minicom/minirc.* 2>/dev/null | sed -e 's|/etc/minicom/minirc.||' | grep "^$cur" ) )
  9253.     fi
  9254. } &&
  9255. complete -F _minicom minicom
  9256.  
  9257. have rrdtool &&
  9258. _rrdtool ()
  9259. {
  9260.     cur=`_get_cword`
  9261.     COMPREPLY=( $( compgen -W 'create update updatev graph dump \
  9262.                                restore last lastupdate first info \
  9263.                                fetch tune resize xport' -- $cur ) )
  9264. } &&
  9265. complete -F _rrdtool rrdtool
  9266.  
  9267. _filedir_xspec()
  9268. {
  9269.     local IFS cur xspec
  9270.  
  9271.     IFS=$'\t\n'
  9272.     COMPREPLY=()
  9273.     cur=`_get_cword`
  9274.  
  9275.     _expand || return 0
  9276.  
  9277.     # get first exclusion compspec that matches this command
  9278.     xspec=$( sed -ne $'/^complete .*[ \t]'${1##*/}$'\([ \t]\|$\)/{p;q;}' \
  9279.           $BASH_COMPLETION )
  9280.     # prune to leave nothing but the -X spec
  9281.     xspec=${xspec#*-X }
  9282.     xspec=${xspec%% *}
  9283.  
  9284.     local -a toks
  9285.     local tmp
  9286.  
  9287.     toks=( ${toks[@]-} $(
  9288.         compgen -d -- "$(quote_readline "$cur")" | {
  9289.             while read -r tmp; do
  9290.                 # see long TODO comment in _filedir() --David
  9291.                 echo $tmp
  9292.             done
  9293.         }
  9294.     ))
  9295.     
  9296.     toks=( ${toks[@]-} $(
  9297.         eval compgen -f -X "$xspec" -- "\$(quote_readline "\$cur")" | {
  9298.             while read -r tmp; do
  9299.                 [ -n $tmp ] && echo $tmp
  9300.             done
  9301.         }
  9302.     ))
  9303.     
  9304.     COMPREPLY=( "${toks[@]}" )
  9305. }
  9306. list=( $( sed -ne '/^# START exclude/,/^# FINISH exclude/p' \
  9307.       $BASH_COMPLETION | \
  9308.     # read exclusion compspecs
  9309.     (
  9310.     while read line
  9311.     do
  9312.         # ignore compspecs that are commented out
  9313.         if [ "${line#\#}" != "$line" ]; then continue; fi
  9314.         line=${line%# START exclude*}
  9315.         line=${line%# FINISH exclude*}
  9316.         line=${line##*\'}
  9317.         list=( "${list[@]}" $line )
  9318.     done
  9319.     echo "${list[@]}"
  9320.     )
  9321.      ) )
  9322. # remove previous compspecs
  9323. if [ ${#list[@]} -gt 0 ]; then
  9324.     eval complete -r ${list[@]}
  9325.     # install new compspecs
  9326.     eval complete -F _filedir_xspec $filenames "${list[@]}"
  9327. fi
  9328. unset list
  9329.  
  9330. # source completion directory definitions
  9331. if [ -d $BASH_COMPLETION_DIR -a -r $BASH_COMPLETION_DIR -a \
  9332.      -x $BASH_COMPLETION_DIR ]; then
  9333.     for i in $BASH_COMPLETION_DIR/*; do
  9334.         [[ ${i##*/} != @(*~|*.bak|*.swp|\#*\#|*.dpkg*|*.rpm@(orig|new|save)) ]] &&
  9335.             [ \( -f $i -o -h $i \) -a -r $i ] && . $i
  9336.     done
  9337. fi
  9338. unset i
  9339.  
  9340. # source user completion file
  9341. [ $BASH_COMPLETION != ~/.bash_completion -a -r ~/.bash_completion ] \
  9342.     && . ~/.bash_completion
  9343. unset -f have
  9344. unset UNAME RELEASE default dirnames filenames have nospace bashdefault \
  9345.       plusdirs
  9346.  
  9347. set $BASH_COMPLETION_ORIGINAL_V_VALUE
  9348. unset BASH_COMPLETION_ORIGINAL_V_VALUE
  9349.